Package org.jboss.metadata.plugins.loader.reflection

Examples of org.jboss.metadata.plugins.loader.reflection.AnnotatedElementMetaDataLoader

191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
    * Tests that the {@link AnnotatedElementMetaDataLoader} correctly identifies
    * bridge methods.
    */
   public void testMethodLevelAnnotationOnBridgeMethodFromParent() throws Exception
   {
      AnnotatedElementMetaDataLoader annotatedElementLoader = new AnnotatedElementMetaDataLoader(BridgeMethodChildBean.class);
     
      Method method = BridgeMethodChildBean.class.getMethod("unambiguous", Object.class);
      assertTrue(method.isBridge());
      MethodSignature methodSignature = new MethodSignature(method);
      MetaDataRetrieval retrieval = annotatedElementLoader.getComponentMetaDataRetrieval(methodSignature);
      assertNotNull("Expected a MetaDataRetrieval for method " + method, retrieval);
      MetaData metadata = new MetaDataRetrievalToMetaDataBridge(retrieval);
      Annotation[] annotations = metadata.getAnnotations();
      assertTrue("Expected one annotation on unambiguous method of " + BridgeMethodChildBean.class, annotations.length == 1);
     
      method = BridgeMethodChildBean.class.getMethod("ambiguous", Object.class);
      assertTrue(method.isBridge());
      methodSignature = new MethodSignature(method);
      assertNull(annotatedElementLoader.getComponentMetaDataRetrieval(methodSignature));
   }
View Full Code Here
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
    * Tests that the {@link AnnotatedElementMetaDataLoader} correctly identifies
    * bridge methods.
    */
   public void testMethodLevelAnnotationOnDeclaredBridgeMethodFromParent() throws Exception
   {
      AnnotatedElementMetaDataLoader annotatedElementLoader = new AnnotatedElementMetaDataLoader(BridgeMethodChildBean.class);

      Method method = BridgeMethodChildBean.class.getMethod("unambiguous", Object.class);
      assertTrue(method.isBridge());
      Signature methodSignature = new DeclaredMethodSignature(method);
      MetaDataRetrieval retrieval = annotatedElementLoader.getComponentMetaDataRetrieval(methodSignature);
      assertNotNull("Expected a MetaDataRetrieval for method " + method, retrieval);
      MetaData metadata = new MetaDataRetrievalToMetaDataBridge(retrieval);
      Annotation[] annotations = metadata.getAnnotations();
      assertTrue("Expected one annotation on unambiguous method of " + BridgeMethodChildBean.class, annotations.length == 1);

      method = BridgeMethodChildBean.class.getMethod("ambiguous", Object.class);
      assertTrue(method.isBridge());
      methodSignature = new DeclaredMethodSignature(method);
      assertNull(annotatedElementLoader.getComponentMetaDataRetrieval(methodSignature));
   }
View Full Code Here
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
    * Tests that overlaoded methods don't cause "No original methods found for..." exception
    * while looking for real method corresponding to a bridged method, through {@link AnnotatedElementMetaDataLoader}
    */
   public void testBridgedMethodWithOverloadedMethods() throws Exception
   {
      AnnotatedElementMetaDataLoader annotatedElementLoader = new AnnotatedElementMetaDataLoader(Child.class);
      // get the bridged method
      Method method = Child.class.getMethod("loadByExample", Event.class, Map.class);
      // Ensure that the bridged method was picked up
      assertTrue("Method " + method + " was expected to be a bridged method", method.isBridge());

      // now just get the ComponentMetaDataRetrieval (which internally triggers the call to search for the
      // non-bridged method).
      Signature methodSignature = new DeclaredMethodSignature(method);
      MetaDataRetrieval retrieval = annotatedElementLoader.getComponentMetaDataRetrieval(methodSignature);
      assertNotNull("Expected a MetaDataRetrieval for method " + method, retrieval);
   }
View Full Code Here
213
214
215
216
217
218
219
220
221
222
223
      if (mode == null)
         mode = BeanAccessMode.STANDARD;

      if (metaData == null)
      {
         MetaDataRetrieval retrieval = new AnnotatedElementMetaDataLoader(beanClass);
         metaData = new MetaDataRetrievalToMetaDataBridge(retrieval);
      }

      if (existingMetaData == null)
      {
View Full Code Here
228
229
230
231
232
233
234
235
236
237
   }

   public static <I> ManagedObject getMO(I mbean, final Class<? extends I> c, ManagedObjectFactory mof)
   {
      AnnotatedElement mbeanClass = c;
      AnnotatedElementMetaDataLoader retrieval = new AnnotatedElementMetaDataLoader(mbeanClass);
      MetaData metaData = new MetaDataRetrievalToMetaDataBridge(retrieval);
      ManagedObject mo = mof.initManagedObject(mbean, c, metaData, null, null);
      return mo;
   }
View Full Code Here
66
67
68
69
70
71
72
73
74
75
76
    * @throws Exception for any error
    */
   public void testNoAnnotationPresent() throws Exception
   {
      // The NoAnnotationBean does not have any annotations
      AnnotatedElementMetaDataLoader annotatedElementLoader = new AnnotatedElementMetaDataLoader(NoAnnotationBean.class);
      MetaData metadata = new MetaDataRetrievalToMetaDataBridge(annotatedElementLoader);
      // should be empty array since the bean has no annotations
      Annotation[] annotations = metadata.getAnnotations();
      assertEmpty(annotations);
   }
View Full Code Here
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
    *
    * @throws Exception for any error
    */
   public void testMethodLevelAnnotationsWithDeclaredMethodSignature() throws Exception
   {
      AnnotatedElementMetaDataLoader annotatedElementLoader = new AnnotatedElementMetaDataLoader(MethodBean.class);
      // Create a DeclaredMethodSignature for the method with 1 annotation
      Method methodWithOneAnnotation = MethodBean.class.getMethod("testAnnotation", new Class<?>[] {String.class});
      DeclaredMethodSignature declaredMethodSignature = new DeclaredMethodSignature(methodWithOneAnnotation);
      // create a retrieval out of it
      MetaDataRetrieval retrieval = annotatedElementLoader.getComponentMetaDataRetrieval(declaredMethodSignature);
      MetaData metadata = new MetaDataRetrievalToMetaDataBridge(retrieval);
      // should be empty array since the bean has no annotations
      Annotation[] annotations = metadata.getAnnotations();
      assertTrue("Expected one annotation on " + methodWithOneAnnotation, annotations.length == 1);
     
      // Now try the same on a method which has 2 annotations
      Method methodWithTwoAnnotations = MethodBean.class.getMethod("testAnnotation12", new Class<?>[] {String.class, Class.class});
      DeclaredMethodSignature anotherDeclaredMethodSignature = new DeclaredMethodSignature(methodWithTwoAnnotations);
      // create a retrieval out of it
      MetaDataRetrieval anotherRetrieval = annotatedElementLoader.getComponentMetaDataRetrieval(anotherDeclaredMethodSignature);
      MetaData anotherMetadata = new MetaDataRetrievalToMetaDataBridge(anotherRetrieval);
      // should be empty array since the bean has no annotations
      Annotation[] annotationsOnMethodWithTwoAnnotations = anotherMetadata.getAnnotations();
      assertTrue("Expected two annotations on " + anotherDeclaredMethodSignature, annotationsOnMethodWithTwoAnnotations.length == 2);
   }
View Full Code Here
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
    *
    * @throws Exception for any error
    */
   public void testMethodLevelAnnotationsWithMethodSignature() throws Exception
   {
      AnnotatedElementMetaDataLoader annotatedElementLoader = new AnnotatedElementMetaDataLoader(MethodBean.class);
      // Create a MethodSignature for the method with 1 annotation
      MethodSignature methodSignature = new MethodSignature("testAnnotation", String.class);
      // create a retrieval out of it
      MetaDataRetrieval retrieval = annotatedElementLoader.getComponentMetaDataRetrieval(methodSignature);
      MetaData metadata = new MetaDataRetrievalToMetaDataBridge(retrieval);
      // should be empty array since the bean has no annotations
      Annotation[] annotations = metadata.getAnnotations();
      assertTrue("Expected one annotation on testAnnotation method of " + MethodBean.class, annotations.length == 1);
     
      // Now try the same on a method which has 2 annotations
      MethodSignature anotherMethodSignature = new MethodSignature("testAnnotation12", String.class, Class.class);
      // create a retrieval out of it
      MetaDataRetrieval anotherRetrieval = annotatedElementLoader.getComponentMetaDataRetrieval(anotherMethodSignature);
      MetaData anotherMetadata = new MetaDataRetrievalToMetaDataBridge(anotherRetrieval);
      // should be empty array since the bean has no annotations
      Annotation[] annotationsOnMethodWithTwoAnnotations = anotherMetadata.getAnnotations();
      assertTrue("Expected two annotations on testAnnotation12 method of " + MethodBean.class, annotationsOnMethodWithTwoAnnotations.length == 2);
   }
View Full Code Here
225
226
227
228
229
230
231
232
233
234
235
      if (mode == null)
         mode = BeanAccessMode.STANDARD;

      if (metaData == null)
      {
         MetaDataRetrieval retrieval = new AnnotatedElementMetaDataLoader(beanClass);
         metaData = new MetaDataRetrievalToMetaDataBridge(retrieval);
      }

      if (existingMetaData == null)
      {
View Full Code Here
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
      }

      public void deploy(DeploymentUnit unit, TestComponentMetaData deployment) throws DeploymentException
      {
         // Create a scope for the class
         AnnotatedElementMetaDataLoader loader = new AnnotatedElementMetaDataLoader(deployment.clazz);
         repository.addMetaDataRetrieval(loader);

         // Add it to our scope
         ScopeKey key = unit.getScope();
         for (Scope scope : loader.getScope().getScopes())
            key.addScope(scope);
        
         // Add the loader
         ScopeKey mutableScope = unit.getMutableScope();
         TestComponentMetaDataLoader componentMetaDataLoader = new TestComponentMetaDataLoader(mutableScope, deployment);
View Full Code Here
TOP

Related Classes of org.jboss.metadata.plugins.loader.reflection.AnnotatedElementMetaDataLoader

  • org.jboss.kernel.spi.annotations.AnnotationToBeanMetaDataFactory
  • org.jboss.managed.plugins.jmx.ManagementFactoryUtils
  • org.jboss.metadata.plugins.loader.SimpleMetaDataLoader
  • org.jboss.metadata.spi.retrieval.simple.SimpleAnnotationItem
  • org.jboss.metadata.spi.retrieval.simple.SimpleAnnotationsItem
  • org.jboss.metadata.spi.scope.Scope
  • org.jboss.metadata.spi.scope.ScopeKey
  • org.jboss.metadata.spi.signature.ConstructorParametersSignature
  • org.jboss.metadata.spi.signature.ConstructorSignature
  • org.jboss.metadata.spi.signature.DeclaredMethodSignature
    • 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.