Package javax.enterprise.inject.spi

Examples of javax.enterprise.inject.spi.Annotated

169
170
171
172
173
174
175
176
177
178
179
    }

    @Test
    @SpecAssertions({ @SpecAssertion(section = PBA, id = "bad") })
    public void testProducerFieldAnnotated() {
        Annotated charlieAnnotated = extension.getAnnotatedMap().get(Charlie.class);
        assertNotNull(charlieAnnotated);
        assertTrue(charlieAnnotated instanceof AnnotatedField);
        @SuppressWarnings("unchecked")
        AnnotatedField<Charlie> charlieAnnotatedField = (AnnotatedField<Charlie>) charlieAnnotated;
        assertEquals(charlieAnnotatedField.getJavaMember().getName(), "charlie");
View Full Code Here
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
    @SuppressWarnings("rawtypes")
    @Test
    @SpecAssertions({ @SpecAssertion(section = INJECTION_POINT, id = "daa"), @SpecAssertion(section = EVENT_METADATA, id = "b") })
    public void testGetAnnotatedType() {

        Annotated lastAnnotated = null;

        notifier.fireInfoEvent();
        lastAnnotated = infoObserver.getLastAnnotated();
        assertTrue(lastAnnotated instanceof AnnotatedField);
        assertEquals(((AnnotatedField) lastAnnotated).getJavaMember().getName(), "infoEvent");
        assertTrue(lastAnnotated.isAnnotationPresent(Inject.class));

        notifier.fireInitializerInfoEvent();
        lastAnnotated = infoObserver.getLastAnnotated();
        assertTrue(lastAnnotated instanceof AnnotatedParameter);
        assertEquals(((AnnotatedParameter) lastAnnotated).getPosition(), 0);

        notifier.fireConstructorInfoEvent();
        lastAnnotated = infoObserver.getLastAnnotated();
        assertTrue(lastAnnotated instanceof AnnotatedParameter);
        assertEquals(((AnnotatedParameter) lastAnnotated).getPosition(), 0);
        assertTrue(lastAnnotated.isAnnotationPresent(Nice.class));
    }
View Full Code Here
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
    @SuppressWarnings("rawtypes")
    @Test
    @SpecAssertion(section=INJECTION_POINT, id="dab")
    public void testInjectionPointGetAnnotated() {

        Annotated fooFieldAnnotated = bar.getFoo().getInjectionPoint().getAnnotated();
        assertTrue(fooFieldAnnotated instanceof AnnotatedField);
        assertEquals(((AnnotatedField) fooFieldAnnotated).getJavaMember().getName(), "fooInstance");
        assertTrue(fooFieldAnnotated.isAnnotationPresent(Any.class));

        Annotated fooInitializerAnnnotated = bar.getInitializerFoo().getInjectionPoint().getAnnotated();
        assertTrue(fooInitializerAnnnotated instanceof AnnotatedParameter);
        assertEquals(((AnnotatedParameter) fooInitializerAnnnotated).getPosition(), 0);

        Annotated fooConstructorAnnnotated = bar.getConstructorInjectionFoo().getInjectionPoint().getAnnotated();
        assertTrue(fooConstructorAnnnotated instanceof AnnotatedParameter);
        assertEquals(((AnnotatedParameter) fooConstructorAnnnotated).getPosition(), 0);
    }
View Full Code Here
80
81
82
83
84
85
86
87
88
89
90
    }

    @Test
    @SpecAssertions({ @SpecAssertion(section = PBA, id = "baa") })
    public void testManagedBeanAnnotated() {
        Annotated alphaAnnotated = extension.getAnnotatedMap().get(Alpha.class);
        assertNotNull(alphaAnnotated);
        assertTrue(alphaAnnotated instanceof AnnotatedType);
        @SuppressWarnings("unchecked")
        AnnotatedType<Alpha> alphaAnnotatedType = (AnnotatedType<Alpha>) alphaAnnotated;
        assertEquals(alphaAnnotatedType.getJavaClass(), Alpha.class);
View Full Code Here
115
116
117
118
119
120
121
122
123
124
125
    }

    @Test
    @SpecAssertions({ @SpecAssertion(section = PBA, id = "bab") })
    public void testSessionBeanAnnotated() {
        Annotated deltaAnnotated = extension.getAnnotatedMap().get(Delta.class);
        assertNotNull(deltaAnnotated);
        assertTrue(deltaAnnotated instanceof AnnotatedType);
        @SuppressWarnings("unchecked")
        AnnotatedType<Delta> deltaAnnotatedType = (AnnotatedType<Delta>) deltaAnnotated;
        assertEquals(deltaAnnotatedType.getJavaClass(), Delta.class);
View Full Code Here
145
146
147
148
149
150
151
152
153
154
155
    }

    @Test
    @SpecAssertions({ @SpecAssertion(section = PBA, id = "bac") })
    public void testProducerMethodAnnotated() {
        Annotated bravoAnnotated = extension.getAnnotatedMap().get(Bravo.class);
        assertNotNull(bravoAnnotated);
        assertTrue(bravoAnnotated instanceof AnnotatedMethod);
        @SuppressWarnings("unchecked")
        AnnotatedMethod<Bravo> bravoAnnotatedMethod = (AnnotatedMethod<Bravo>) bravoAnnotated;
        assertEquals(bravoAnnotatedMethod.getJavaMember().getName(), "createBravo");
View Full Code Here
172
173
174
175
176
177
178
179
180
181
182
    }

    @Test
    @SpecAssertions({ @SpecAssertion(section = PBA, id = "bad") })
    public void testProducerFieldAnnotated() {
        Annotated charlieAnnotated = extension.getAnnotatedMap().get(Charlie.class);
        assertNotNull(charlieAnnotated);
        assertTrue(charlieAnnotated instanceof AnnotatedField);
        @SuppressWarnings("unchecked")
        AnnotatedField<Charlie> charlieAnnotatedField = (AnnotatedField<Charlie>) charlieAnnotated;
        assertEquals(charlieAnnotatedField.getJavaMember().getName(), "charlie");
View Full Code Here
186
187
188
189
190
191
192
193
194
195
196
      return false;
    }

    @Override
    public Annotated getAnnotated() {
      return new Annotated() {

        @Override
        public Type getBaseType() {
          // TODO Auto-generated method stub
          return null;
View Full Code Here
54
55
56
57
58
59
60
61
62
63
64
65
    this.environment = environment;
  }
 
  @Produces @Property
  public String get(InjectionPoint ip) {
    Annotated annotated = ip.getAnnotated();
    Property property = annotated.getAnnotation(Property.class);
    String key = property.value();
    if (isNullOrEmpty(key)) {
      key = ip.getMember().getName();
    }
   
View Full Code Here
197
198
199
200
201
202
203
204
205
206
207
208
        {
            if(!injectionPoint.isTransient())
            {
                if(!webBeansContext.getWebBeansUtil().isPassivationCapableDependency(injectionPoint))
                {
                    Annotated annotated = injectionPoint.getAnnotated();
                    if(annotated.isAnnotationPresent(Disposes.class) || annotated.isAnnotationPresent(TransientReference.class))
                    {
                        continue;
                    }
                    throw new WebBeansConfigurationException(
                            "Passivation capable beans must satisfy passivation capable dependencies. " +
View Full Code Here
TOP

Related Classes of javax.enterprise.inject.spi.Annotated

  • br.com.caelum.vraptor.environment.EnvironmentPropertyProducer
  • br.gov.frameworkdemoiselle.util.Beans$CustomInjectionPoint
  • com.cathive.fx.cdi.CdiFXMLLoaderFactory
  • com.cathive.fx.cdi.internal.FXMLLoaderFactory
  • com.caucho.config.inject.AbstractBean
  • com.caucho.config.inject.InjectionPointImplHandle
  • com.caucho.config.inject.InjectManager
  • com.caucho.config.inject.InjectManager$InjectBean
  • com.caucho.config.inject.InjectManager$TypedBean
  • com.caucho.config.inject.WebComponent
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.