Search in sources :

Example 1 with ProcessAnnotatedType

use of jakarta.enterprise.inject.spi.ProcessAnnotatedType in project core by weld.

the class ProbeExtensionsTest method testExtensionVisibleInProbe.

@Test
public void testExtensionVisibleInProbe() throws IOException {
    JsonObject beansInTestArchive = getPageAsJSONObject(BEANS_PATH_ALL, url);
    assertNotNull(beansInTestArchive);
    JsonArray beansArray = beansInTestArchive.getJsonArray(DATA);
    ReadContext ctx = JsonPath.parse(beansInTestArchive.toString());
    List<String> beanClasses = ctx.read("$." + DATA + "[*]." + BEAN_CLASS, List.class);
    assertBeanClassVisibleInProbe(TestExtension.class, beanClasses);
    // test extension attributes
    JsonObject extensionBeanDetail = getBeanDetail(BEANS_PATH_ALL, TestExtension.class, url);
    assertEquals(BeanType.EXTENSION.name(), extensionBeanDetail.getString(KIND));
    ctx = JsonPath.parse(extensionBeanDetail.toString());
    List<String> observedTypes = ctx.read("$." + DECLARED_OBSERVERS + "[*]." + OBSERVED_TYPE, List.class);
    assertTrue("Cannot find ProcessAnnotatedType observer method!", observedTypes.contains(ProcessAnnotatedType.class.getName() + "<DummyBean>"));
    // test bean altered by extension
    JsonObject dummyBeanDetail = getBeanDetail(BEANS_PATH_ALL, DummyBean.class, url);
    ctx = JsonPath.parse(dummyBeanDetail.toString());
    List<String> qualifiers = ctx.read("$." + QUALIFIERS + "[*]", List.class);
    assertTrue("Cannot find " + Collector.class + " qualifier on " + DummyBean.class, qualifiers.contains("@" + Collector.class.getName().concat("(value=\"\")")));
}
Also used : JsonArray(javax.json.JsonArray) ProcessAnnotatedType(jakarta.enterprise.inject.spi.ProcessAnnotatedType) ReadContext(com.jayway.jsonpath.ReadContext) Collector(org.jboss.weld.probe.tests.integration.deployment.annotations.Collector) JsonObject(javax.json.JsonObject) DummyBean(org.jboss.weld.probe.tests.integration.deployment.beans.DummyBean) Test(org.junit.Test)

Example 2 with ProcessAnnotatedType

use of jakarta.enterprise.inject.spi.ProcessAnnotatedType in project core by weld.

the class FastProcessAnnotatedTypeResolver method process.

private void process(ContainerLifecycleEventObserverMethod<?> observer, Type observedType) throws UnsupportedObserverMethodException {
    if (Object.class.equals(observedType)) {
        // void observe(Object event)
        catchAllObservers.add(observer);
    } else if (ProcessAnnotatedType.class.equals(observedType)) {
        // void observe(ProcessAnnotatedType event)
        catchAllObservers.add(observer);
    } else if (observedType instanceof ParameterizedType) {
        ParameterizedType type = (ParameterizedType) observedType;
        if (ProcessAnnotatedType.class.equals(type.getRawType())) {
            Type typeParameter = type.getActualTypeArguments()[0];
            if (typeParameter instanceof Class<?>) {
                this.observers.put(observer, new ExactTypePredicate(Reflections.getRawType(typeParameter)));
            } else if (typeParameter instanceof ParameterizedType) {
                /*
                     * The event type always has the form of ProcessAnnotatedType<X> where X is a raw type.
                     * Therefore, no event will ever match an observer with type ProcessAnnotatedType<Foo<Y>> no matter
                     * what Y is. This would be because primarily because parameterized are invariant. Event for an exact match
                     * of the raw type, Foo raw event type is not assignable to Foo<?> parameterized type according to CDI assignability rules.
                     */
                return;
            } else if (typeParameter instanceof WildcardType) {
                // void observe(ProcessAnnotatedType<?> event)
                WildcardType wildCard = (WildcardType) typeParameter;
                checkBounds(observer, wildCard.getUpperBounds());
                this.observers.put(observer, CompositePredicate.assignable(Types.getRawTypes(wildCard.getUpperBounds())));
            } else if (typeParameter instanceof TypeVariable<?>) {
                // <T> void observe(ProcessAnnotatedType<T> event)
                TypeVariable<?> variable = (TypeVariable<?>) typeParameter;
                checkBounds(observer, variable.getBounds());
                this.observers.put(observer, CompositePredicate.assignable(Types.getRawTypes(variable.getBounds())));
            }
        }
    } else if (observedType instanceof TypeVariable<?>) {
        defaultRules(observer, observedType);
    }
}
Also used : ProcessAnnotatedType(jakarta.enterprise.inject.spi.ProcessAnnotatedType) ParameterizedType(java.lang.reflect.ParameterizedType) WildcardType(java.lang.reflect.WildcardType) ParameterizedType(java.lang.reflect.ParameterizedType) ProcessAnnotatedType(jakarta.enterprise.inject.spi.ProcessAnnotatedType) Type(java.lang.reflect.Type) WildcardType(java.lang.reflect.WildcardType) TypeVariable(java.lang.reflect.TypeVariable)

Example 3 with ProcessAnnotatedType

use of jakarta.enterprise.inject.spi.ProcessAnnotatedType in project core by weld.

the class ContainerLifecyleObserverTest method testExtensionBuilder.

@SuppressWarnings({ "serial" })
@Test
public void testExtensionBuilder() {
    ActionSequence.reset();
    Extension myExtension = ContainerLifecycleObserver.extensionBuilder().add(beforeBeanDiscovery((e) -> addAction(BeforeBeanDiscovery.class.getSimpleName()))).add(afterTypeDiscovery().notify((e, b) -> {
        addAction(AfterTypeDiscovery.class.getSimpleName());
        e.addAnnotatedType(b.createAnnotatedType(Charlie.class), Charlie.class.getName());
    })).add(afterBeanDiscovery((e) -> {
        addAction(AfterBeanDiscovery.class.getSimpleName());
        e.addObserverMethod().beanClass(Foo.class).observedType(Foo.class).notifyWith((ctx) -> {
        });
        e.addBean().beanClass(Integer.class).addType(Integer.class).addQualifier(Juicy.Literal.INSTANCE).createWith((ctx) -> Integer.valueOf(10));
    })).add(afterDeploymentValidation((e) -> addAction(AfterDeploymentValidation.class.getSimpleName()))).add(beforeShutdown((e) -> addAction(BeforeShutdown.class.getSimpleName()))).build();
    Extension myExtension2 = ContainerLifecycleObserver.extensionBuilder().add(processAnnotatedType().withAnnotations(RequestScoped.class).notify((e) -> e.veto())).add(processBeanAttributes().notify((e) -> addAction(ProcessBeanAttributes.class.getSimpleName()))).add(processSyntheticAnnotatedType(new TypeLiteral<ProcessSyntheticAnnotatedType<?>>() {
    }.getType()).notify((e) -> addAction(ProcessSyntheticAnnotatedType.class.getSimpleName()))).add(processInjectionPoint().notify((e) -> addAction(ProcessInjectionPoint.class.getSimpleName()))).add(processProducer().notify((e) -> addAction(ProcessProducer.class.getSimpleName()))).add(processBean().notify((e) -> addAction(ProcessBean.class.getSimpleName()))).add(processManagedBean().notify((e) -> addAction(ProcessManagedBean.class.getSimpleName()))).add(processProducerField().notify((e) -> addAction(ProcessProducerField.class.getSimpleName()))).add(processProducerMethod().notify((e) -> {
        // Weld SE defines some producer methods, e.g. ParametersFactory
        addAction(ProcessProducerMethod.class.getSimpleName());
    })).add(processBeanAttributes().notify((e) -> addAction(ProcessBeanAttributes.class.getSimpleName()))).add(processObserverMethod().notify((e) -> addAction(ProcessObserverMethod.class.getSimpleName()))).add(processObserverMethod(new TypeLiteral<ProcessObserverMethod<String, ?>>() {
    }.getType()).notify((e) -> addAction(ProcessObserverMethod.class.getSimpleName() + String.class.getSimpleName()))).add(processSyntheticObserverMethod(new TypeLiteral<ProcessSyntheticObserverMethod<Foo, ?>>() {
    }.getType()).notify((e) -> addAction(ProcessSyntheticObserverMethod.class.getSimpleName() + Foo.class.getSimpleName()))).add(processSyntheticBean(new TypeLiteral<ProcessSyntheticBean<Integer>>() {
    }.getType()).notify((e) -> addAction(ProcessSyntheticBean.class.getSimpleName() + Integer.class.getSimpleName()))).build();
    try (WeldContainer container = new Weld().disableDiscovery().beanClasses(Foo.class, Bravo.class).addExtension(myExtension).addExtension(myExtension2).initialize()) {
        assertTrue(container.select(Foo.class).isUnsatisfied());
        assertFalse(container.select(Bravo.class).isUnsatisfied());
        Assert.assertEquals(Integer.valueOf(10), container.select(Integer.class, Juicy.Literal.INSTANCE).get());
    }
    ActionSequence.assertSequenceDataContainsAll(BeforeBeanDiscovery.class, AfterTypeDiscovery.class, AfterBeanDiscovery.class, AfterDeploymentValidation.class, BeforeShutdown.class);
    ActionSequence.assertSequenceDataContainsAll(ProcessBeanAttributes.class, ProcessSyntheticAnnotatedType.class, ProcessInjectionPoint.class, ProcessObserverMethod.class, ProcessBeanAttributes.class, ProcessProducer.class);
    ActionSequence.assertSequenceDataContainsAll(ProcessObserverMethod.class.getSimpleName() + String.class.getSimpleName(), ProcessSyntheticObserverMethod.class.getSimpleName() + Foo.class.getSimpleName(), ProcessSyntheticBean.class.getSimpleName() + Integer.class.getSimpleName());
    ActionSequence.assertSequenceDataContainsAll(ProcessBean.class, ProcessManagedBean.class, ProcessProducerMethod.class, ProcessProducerField.class);
}
Also used : ContainerLifecycleObserver.processObserverMethod(org.jboss.weld.environment.se.ContainerLifecycleObserver.processObserverMethod) ContainerLifecycleObserver.processSyntheticBean(org.jboss.weld.environment.se.ContainerLifecycleObserver.processSyntheticBean) ContainerLifecycleObserver.beforeBeanDiscovery(org.jboss.weld.environment.se.ContainerLifecycleObserver.beforeBeanDiscovery) ProcessObserverMethod(jakarta.enterprise.inject.spi.ProcessObserverMethod) ContainerLifecycleObserver.afterBeanDiscovery(org.jboss.weld.environment.se.ContainerLifecycleObserver.afterBeanDiscovery) ProcessSyntheticObserverMethod(jakarta.enterprise.inject.spi.ProcessSyntheticObserverMethod) ContainerLifecycleObserver.afterTypeDiscovery(org.jboss.weld.environment.se.ContainerLifecycleObserver.afterTypeDiscovery) AfterTypeDiscovery(jakarta.enterprise.inject.spi.AfterTypeDiscovery) AtomicBoolean(java.util.concurrent.atomic.AtomicBoolean) AfterDeploymentValidation(jakarta.enterprise.inject.spi.AfterDeploymentValidation) ProcessInjectionPoint(jakarta.enterprise.inject.spi.ProcessInjectionPoint) ContainerLifecycleObserver.processProducer(org.jboss.weld.environment.se.ContainerLifecycleObserver.processProducer) ProcessManagedBean(jakarta.enterprise.inject.spi.ProcessManagedBean) ProcessSyntheticAnnotatedType(jakarta.enterprise.inject.spi.ProcessSyntheticAnnotatedType) ContainerLifecycleObserver.processBean(org.jboss.weld.environment.se.ContainerLifecycleObserver.processBean) ContainerLifecycleObserver.beforeShutdown(org.jboss.weld.environment.se.ContainerLifecycleObserver.beforeShutdown) ProcessBeanAttributes(jakarta.enterprise.inject.spi.ProcessBeanAttributes) TypeLiteral(jakarta.enterprise.util.TypeLiteral) ProcessBean(jakarta.enterprise.inject.spi.ProcessBean) ProcessProducerMethod(jakarta.enterprise.inject.spi.ProcessProducerMethod) Extension(jakarta.enterprise.inject.spi.Extension) ProcessAnnotatedType(jakarta.enterprise.inject.spi.ProcessAnnotatedType) BeforeBeanDiscovery(jakarta.enterprise.inject.spi.BeforeBeanDiscovery) ActionSequence(org.jboss.weld.test.util.ActionSequence) ContainerLifecycleObserver.processInjectionPoint(org.jboss.weld.environment.se.ContainerLifecycleObserver.processInjectionPoint) ContainerLifecycleObserver.processSyntheticAnnotatedType(org.jboss.weld.environment.se.ContainerLifecycleObserver.processSyntheticAnnotatedType) ContainerLifecycleObserver.processProducerField(org.jboss.weld.environment.se.ContainerLifecycleObserver.processProducerField) Weld(org.jboss.weld.environment.se.Weld) ContainerLifecycleObserver.processSyntheticObserverMethod(org.jboss.weld.environment.se.ContainerLifecycleObserver.processSyntheticObserverMethod) BeforeShutdown(jakarta.enterprise.inject.spi.BeforeShutdown) Assert.assertTrue(org.junit.Assert.assertTrue) Test(org.junit.Test) ContainerLifecycleObserver.processManagedBean(org.jboss.weld.environment.se.ContainerLifecycleObserver.processManagedBean) WeldContainer(org.jboss.weld.environment.se.WeldContainer) ProcessSyntheticBean(jakarta.enterprise.inject.spi.ProcessSyntheticBean) ContainerLifecycleObserver.afterDeploymentValidation(org.jboss.weld.environment.se.ContainerLifecycleObserver.afterDeploymentValidation) ContainerLifecycleObserver.processProducerMethod(org.jboss.weld.environment.se.ContainerLifecycleObserver.processProducerMethod) AfterBeanDiscovery(jakarta.enterprise.inject.spi.AfterBeanDiscovery) ContainerLifecycleObserver(org.jboss.weld.environment.se.ContainerLifecycleObserver) Assert.assertFalse(org.junit.Assert.assertFalse) ActionSequence.addAction(org.jboss.weld.test.util.ActionSequence.addAction) ProcessProducerField(jakarta.enterprise.inject.spi.ProcessProducerField) ContainerLifecycleObserver.processAnnotatedType(org.jboss.weld.environment.se.ContainerLifecycleObserver.processAnnotatedType) ProcessProducer(jakarta.enterprise.inject.spi.ProcessProducer) Assert(org.junit.Assert) ContainerLifecycleObserver.processBeanAttributes(org.jboss.weld.environment.se.ContainerLifecycleObserver.processBeanAttributes) RequestScoped(jakarta.enterprise.context.RequestScoped) WeldContainer(org.jboss.weld.environment.se.WeldContainer) AfterDeploymentValidation(jakarta.enterprise.inject.spi.AfterDeploymentValidation) ProcessObserverMethod(jakarta.enterprise.inject.spi.ProcessObserverMethod) ProcessSyntheticAnnotatedType(jakarta.enterprise.inject.spi.ProcessSyntheticAnnotatedType) Weld(org.jboss.weld.environment.se.Weld) Extension(jakarta.enterprise.inject.spi.Extension) ProcessManagedBean(jakarta.enterprise.inject.spi.ProcessManagedBean) ProcessSyntheticBean(jakarta.enterprise.inject.spi.ProcessSyntheticBean) TypeLiteral(jakarta.enterprise.util.TypeLiteral) ProcessProducer(jakarta.enterprise.inject.spi.ProcessProducer) AfterBeanDiscovery(jakarta.enterprise.inject.spi.AfterBeanDiscovery) Test(org.junit.Test)

Example 4 with ProcessAnnotatedType

use of jakarta.enterprise.inject.spi.ProcessAnnotatedType in project helidon by oracle.

the class MicronautCdiExtension method processTypes.

/**
 * Construct a list of Micronaut interceptors to execute on each CDI method.
 * In case a Micronaut bean definition is available for the CDI bean (which should be for application, as
 * the CDI annotation processor should be used, and it adds CDI beans as Micronaut beans), the information
 * is combined from Micronaut and CDI bean definitions.
 *
 * @param event CDI event
 */
@SuppressWarnings("unchecked")
void processTypes(@Priority(PLATFORM_AFTER) @Observes ProcessAnnotatedType<?> event) {
    Set<Class<?>> classInterceptors = new HashSet<>();
    Map<Method, Set<Class<?>>> allMethodInterceptors = new HashMap<>();
    List<MicronautBean> miBeans = unprocessedBeans.remove(event.getAnnotatedType().getJavaClass());
    if (miBeans != null && miBeans.size() > 0) {
        BeanDefinitionReference<?> miBean = findMicronautBeanDefinition(miBeans);
        // add all interceptors that are seen based on Micronaut
        findMicronautInterceptors(classInterceptors, allMethodInterceptors, miBean);
    }
    // find all annotations that have meta annotation Around and collect their Type list to add as interceptors
    addMicronautInterceptors(classInterceptors, event.getAnnotatedType().getAnnotations());
    // for each method, find the same (Around, collect Type), and add the interceptor binding for Micronaut interceptors
    // CDI interceptors will be automatic
    event.configureAnnotatedType().methods().forEach(method -> {
        Method javaMethod = method.getAnnotated().getJavaMember();
        Set<Class<?>> methodInterceptors = allMethodInterceptors.computeIfAbsent(javaMethod, it -> new HashSet<>());
        methodInterceptors.addAll(classInterceptors);
        addMicronautInterceptors(methodInterceptors, method.getAnnotated().getAnnotations());
        if (!methodInterceptors.isEmpty()) {
            // now I have a set of micronaut interceptors that are needed for this method
            method.add(MicronautIntercepted.Literal.INSTANCE);
            Set<Class<? extends MethodInterceptor<?, ?>>> interceptors = new HashSet<>();
            methodInterceptors.forEach(it -> interceptors.add((Class<? extends MethodInterceptor<?, ?>>) it));
            methods.computeIfAbsent(javaMethod, theMethod -> MethodInterceptorMetadata.create(method.getAnnotated(), executableMethodCache.get(theMethod))).addInterceptors(interceptors);
        }
    });
}
Also used : Dependent(jakarta.enterprise.context.Dependent) Around(io.micronaut.aop.Around) Observes(jakarta.enterprise.event.Observes) ApplicationScoped(jakarta.enterprise.context.ApplicationScoped) HashMap(java.util.HashMap) AtomicReference(java.util.concurrent.atomic.AtomicReference) ExecutableMethod(io.micronaut.inject.ExecutableMethod) ArrayList(java.util.ArrayList) Level(java.util.logging.Level) HashSet(java.util.HashSet) SoftServiceLoader(io.micronaut.core.io.service.SoftServiceLoader) ApplicationContext(io.micronaut.context.ApplicationContext) Extension(jakarta.enterprise.inject.spi.Extension) ProcessAnnotatedType(jakarta.enterprise.inject.spi.ProcessAnnotatedType) BeforeBeanDiscovery(jakarta.enterprise.inject.spi.BeforeBeanDiscovery) MethodInterceptor(io.micronaut.aop.MethodInterceptor) Map(java.util.Map) PLATFORM_AFTER(jakarta.interceptor.Interceptor.Priority.PLATFORM_AFTER) BeanConfigurator(jakarta.enterprise.inject.spi.configurator.BeanConfigurator) Priority(jakarta.annotation.Priority) LinkedList(java.util.LinkedList) Method(java.lang.reflect.Method) Initialized(jakarta.enterprise.context.Initialized) PLATFORM_BEFORE(jakarta.interceptor.Interceptor.Priority.PLATFORM_BEFORE) Iterator(java.util.Iterator) PropertySource(io.micronaut.context.env.PropertySource) Collection(java.util.Collection) ServiceDefinition(io.micronaut.core.io.service.ServiceDefinition) Set(java.util.Set) Qualifiers(io.micronaut.inject.qualifiers.Qualifiers) AdvisedBeanType(io.micronaut.inject.AdvisedBeanType) Config(org.eclipse.microprofile.config.Config) Logger(java.util.logging.Logger) Collectors(java.util.stream.Collectors) BeforeDestroyed(jakarta.enterprise.context.BeforeDestroyed) Objects(java.util.Objects) List(java.util.List) Type(io.micronaut.context.annotation.Type) Stream(java.util.stream.Stream) AfterBeanDiscovery(jakarta.enterprise.inject.spi.AfterBeanDiscovery) Annotation(java.lang.annotation.Annotation) AnnotationMetadata(io.micronaut.core.annotation.AnnotationMetadata) BeanDefinition(io.micronaut.inject.BeanDefinition) Comparator(java.util.Comparator) Qualifier(jakarta.inject.Qualifier) BeanDefinitionReference(io.micronaut.inject.BeanDefinitionReference) HashSet(java.util.HashSet) Set(java.util.Set) HashMap(java.util.HashMap) ExecutableMethod(io.micronaut.inject.ExecutableMethod) Method(java.lang.reflect.Method) MethodInterceptor(io.micronaut.aop.MethodInterceptor) HashSet(java.util.HashSet)

Example 5 with ProcessAnnotatedType

use of jakarta.enterprise.inject.spi.ProcessAnnotatedType in project core by weld.

the class ContainerLifecyleObserverTest method testAddContainerLifecycleObserver.

@SuppressWarnings("serial")
@Test
public void testAddContainerLifecycleObserver() {
    final AtomicBoolean called = new AtomicBoolean(false);
    try (WeldContainer container = new Weld().disableDiscovery().beanClasses(Foo.class).addContainerLifecycleObserver(processAnnotatedType(new TypeLiteral<ProcessAnnotatedType<Foo>>() {
    }.getType()).notify((e) -> e.veto())).addContainerLifecycleObserver(afterBeanDiscovery((e) -> called.set(true))).initialize()) {
        assertTrue(called.get());
        assertTrue(container.select(Foo.class).isUnsatisfied());
    }
}
Also used : ContainerLifecycleObserver.processObserverMethod(org.jboss.weld.environment.se.ContainerLifecycleObserver.processObserverMethod) ContainerLifecycleObserver.processSyntheticBean(org.jboss.weld.environment.se.ContainerLifecycleObserver.processSyntheticBean) ContainerLifecycleObserver.beforeBeanDiscovery(org.jboss.weld.environment.se.ContainerLifecycleObserver.beforeBeanDiscovery) ProcessObserverMethod(jakarta.enterprise.inject.spi.ProcessObserverMethod) ContainerLifecycleObserver.afterBeanDiscovery(org.jboss.weld.environment.se.ContainerLifecycleObserver.afterBeanDiscovery) ProcessSyntheticObserverMethod(jakarta.enterprise.inject.spi.ProcessSyntheticObserverMethod) ContainerLifecycleObserver.afterTypeDiscovery(org.jboss.weld.environment.se.ContainerLifecycleObserver.afterTypeDiscovery) AfterTypeDiscovery(jakarta.enterprise.inject.spi.AfterTypeDiscovery) AtomicBoolean(java.util.concurrent.atomic.AtomicBoolean) AfterDeploymentValidation(jakarta.enterprise.inject.spi.AfterDeploymentValidation) ProcessInjectionPoint(jakarta.enterprise.inject.spi.ProcessInjectionPoint) ContainerLifecycleObserver.processProducer(org.jboss.weld.environment.se.ContainerLifecycleObserver.processProducer) ProcessManagedBean(jakarta.enterprise.inject.spi.ProcessManagedBean) ProcessSyntheticAnnotatedType(jakarta.enterprise.inject.spi.ProcessSyntheticAnnotatedType) ContainerLifecycleObserver.processBean(org.jboss.weld.environment.se.ContainerLifecycleObserver.processBean) ContainerLifecycleObserver.beforeShutdown(org.jboss.weld.environment.se.ContainerLifecycleObserver.beforeShutdown) ProcessBeanAttributes(jakarta.enterprise.inject.spi.ProcessBeanAttributes) TypeLiteral(jakarta.enterprise.util.TypeLiteral) ProcessBean(jakarta.enterprise.inject.spi.ProcessBean) ProcessProducerMethod(jakarta.enterprise.inject.spi.ProcessProducerMethod) Extension(jakarta.enterprise.inject.spi.Extension) ProcessAnnotatedType(jakarta.enterprise.inject.spi.ProcessAnnotatedType) BeforeBeanDiscovery(jakarta.enterprise.inject.spi.BeforeBeanDiscovery) ActionSequence(org.jboss.weld.test.util.ActionSequence) ContainerLifecycleObserver.processInjectionPoint(org.jboss.weld.environment.se.ContainerLifecycleObserver.processInjectionPoint) ContainerLifecycleObserver.processSyntheticAnnotatedType(org.jboss.weld.environment.se.ContainerLifecycleObserver.processSyntheticAnnotatedType) ContainerLifecycleObserver.processProducerField(org.jboss.weld.environment.se.ContainerLifecycleObserver.processProducerField) Weld(org.jboss.weld.environment.se.Weld) ContainerLifecycleObserver.processSyntheticObserverMethod(org.jboss.weld.environment.se.ContainerLifecycleObserver.processSyntheticObserverMethod) BeforeShutdown(jakarta.enterprise.inject.spi.BeforeShutdown) Assert.assertTrue(org.junit.Assert.assertTrue) Test(org.junit.Test) ContainerLifecycleObserver.processManagedBean(org.jboss.weld.environment.se.ContainerLifecycleObserver.processManagedBean) WeldContainer(org.jboss.weld.environment.se.WeldContainer) ProcessSyntheticBean(jakarta.enterprise.inject.spi.ProcessSyntheticBean) ContainerLifecycleObserver.afterDeploymentValidation(org.jboss.weld.environment.se.ContainerLifecycleObserver.afterDeploymentValidation) ContainerLifecycleObserver.processProducerMethod(org.jboss.weld.environment.se.ContainerLifecycleObserver.processProducerMethod) AfterBeanDiscovery(jakarta.enterprise.inject.spi.AfterBeanDiscovery) ContainerLifecycleObserver(org.jboss.weld.environment.se.ContainerLifecycleObserver) Assert.assertFalse(org.junit.Assert.assertFalse) ActionSequence.addAction(org.jboss.weld.test.util.ActionSequence.addAction) ProcessProducerField(jakarta.enterprise.inject.spi.ProcessProducerField) ContainerLifecycleObserver.processAnnotatedType(org.jboss.weld.environment.se.ContainerLifecycleObserver.processAnnotatedType) ProcessProducer(jakarta.enterprise.inject.spi.ProcessProducer) Assert(org.junit.Assert) ContainerLifecycleObserver.processBeanAttributes(org.jboss.weld.environment.se.ContainerLifecycleObserver.processBeanAttributes) RequestScoped(jakarta.enterprise.context.RequestScoped) AtomicBoolean(java.util.concurrent.atomic.AtomicBoolean) TypeLiteral(jakarta.enterprise.util.TypeLiteral) WeldContainer(org.jboss.weld.environment.se.WeldContainer) Weld(org.jboss.weld.environment.se.Weld) Test(org.junit.Test)

Aggregations

ProcessAnnotatedType (jakarta.enterprise.inject.spi.ProcessAnnotatedType)5 AfterBeanDiscovery (jakarta.enterprise.inject.spi.AfterBeanDiscovery)3 BeforeBeanDiscovery (jakarta.enterprise.inject.spi.BeforeBeanDiscovery)3 Extension (jakarta.enterprise.inject.spi.Extension)3 RequestScoped (jakarta.enterprise.context.RequestScoped)2 AfterDeploymentValidation (jakarta.enterprise.inject.spi.AfterDeploymentValidation)2 AfterTypeDiscovery (jakarta.enterprise.inject.spi.AfterTypeDiscovery)2 BeforeShutdown (jakarta.enterprise.inject.spi.BeforeShutdown)2 ProcessBean (jakarta.enterprise.inject.spi.ProcessBean)2 ProcessBeanAttributes (jakarta.enterprise.inject.spi.ProcessBeanAttributes)2 ProcessInjectionPoint (jakarta.enterprise.inject.spi.ProcessInjectionPoint)2 ProcessManagedBean (jakarta.enterprise.inject.spi.ProcessManagedBean)2 ProcessObserverMethod (jakarta.enterprise.inject.spi.ProcessObserverMethod)2 ProcessProducer (jakarta.enterprise.inject.spi.ProcessProducer)2 ProcessProducerField (jakarta.enterprise.inject.spi.ProcessProducerField)2 ProcessProducerMethod (jakarta.enterprise.inject.spi.ProcessProducerMethod)2 ProcessSyntheticAnnotatedType (jakarta.enterprise.inject.spi.ProcessSyntheticAnnotatedType)2 ProcessSyntheticBean (jakarta.enterprise.inject.spi.ProcessSyntheticBean)2 ProcessSyntheticObserverMethod (jakarta.enterprise.inject.spi.ProcessSyntheticObserverMethod)2 Test (org.junit.Test)2