[jboss-cvs] JBossAS SVN: r97553 - in projects/jboss-mdr/trunk/src: main/java/org/jboss/metadata/plugins/loader and 3 other directories.
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Tue Dec 8 12:36:49 EST 2009
Author: kabir.khan at jboss.com
Date: 2009-12-08 12:36:49 -0500 (Tue, 08 Dec 2009)
New Revision: 97553
Removed:
projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/spi/retrieval/cummulative/CummulativeAnnotationsFilter.java
Modified:
projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/plugins/context/AbstractMetaDataContext.java
projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/plugins/context/CachingMetaDataContext.java
projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/plugins/loader/AbstractMetaDataLoader.java
projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/plugins/loader/memory/MemoryMetaDataLoader.java
projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/spi/retrieval/cummulative/CummulativeAnnotationsItem.java
projects/jboss-mdr/trunk/src/test/java/org/jboss/test/metadata/context/cache/test/SimpleCacheMetaDataContextUnitTestCase.java
Log:
[JBMDR-62] Add caching of the annotations annotated with
Modified: projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/plugins/context/AbstractMetaDataContext.java
===================================================================
--- projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/plugins/context/AbstractMetaDataContext.java 2009-12-08 17:30:52 UTC (rev 97552)
+++ projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/plugins/context/AbstractMetaDataContext.java 2009-12-08 17:36:49 UTC (rev 97553)
@@ -25,7 +25,9 @@
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;
import org.jboss.metadata.spi.context.MetaDataContext;
@@ -35,7 +37,7 @@
import org.jboss.metadata.spi.retrieval.MetaDataRetrieval;
import org.jboss.metadata.spi.retrieval.MetaDatasItem;
import org.jboss.metadata.spi.retrieval.ValidTime;
-import org.jboss.metadata.spi.retrieval.cummulative.CummulativeAnnotationsFilter;
+import org.jboss.metadata.spi.retrieval.basic.BasicAnnotationsItem;
import org.jboss.metadata.spi.retrieval.cummulative.CummulativeAnnotationsItem;
import org.jboss.metadata.spi.retrieval.cummulative.CummulativeMetaDatasItem;
import org.jboss.metadata.spi.scope.Scope;
@@ -228,7 +230,9 @@
public AnnotationsItem retrieveAnnotationsAnnotatedWith(Class<? extends Annotation> meta)
{
- return new CummulativeAnnotationsItem(this, true, new AnnotationsAnnotatedWithFilter(meta));
+ @SuppressWarnings("unchecked")
+ Map<Class, AnnotationsItem> map = retrieveAnnotationsAnnotatedWithIndex();
+ return map.get(meta);
}
public MetaDatasItem retrieveMetaData()
@@ -333,18 +337,51 @@
/**
* Only match annotations with meta annotation.
*/
- private static class AnnotationsAnnotatedWithFilter implements CummulativeAnnotationsFilter
+ @SuppressWarnings("unchecked")
+ protected Map<Class, AnnotationsItem> retrieveAnnotationsAnnotatedWithIndex()
{
- private Class<? extends Annotation> meta;
-
- public AnnotationsAnnotatedWithFilter(Class<? extends Annotation> meta)
+ Map<Class, AnnotationsItem> result = new HashMap<Class, AnnotationsItem>();
+ AnnotationsItem item = retrieveAnnotations();
+ if (item.getAnnotations().length > 0)
{
- this.meta = meta;
+ Map<Class<? extends Annotation>, List<AnnotationItem<?>>> annotations = new HashMap<Class<? extends Annotation>, List<AnnotationItem<?>>>();
+ for (AnnotationItem<?> annotation : item.getAnnotations())
+ {
+ for (Annotation current : annotation.getAnnotation().annotationType().getAnnotations())
+ {
+ List<AnnotationItem<?>> annotationsForMeta = annotations.get(current.annotationType());
+ if (annotationsForMeta == null)
+ {
+ annotationsForMeta = new ArrayList<AnnotationItem<?>>();
+ annotations.put(current.annotationType(), annotationsForMeta);
+ }
+ annotationsForMeta.add(annotation);
+ }
+ }
+
+ for (Map.Entry<Class<? extends Annotation>, List<AnnotationItem<?>>> entry : annotations.entrySet())
+ {
+ AnnotationsItem basic = new AnnotationsAnnotatedWithAnnotationsItem(entry.getValue().toArray(new AnnotationItem<?>[entry.getValue().size()] ));
+ result.put(entry.getKey(), basic);
+ }
+
}
+ return result;
+ }
+
+ static class AnnotationsAnnotatedWithAnnotationsItem extends BasicAnnotationsItem
+ {
+ private boolean cachable = true;
- public AnnotationsItem getAnnotations(MetaDataRetrieval retrieval)
+ AnnotationsAnnotatedWithAnnotationsItem(AnnotationItem<? extends Annotation>[] annotationItems)
{
- return retrieval.retrieveAnnotationsAnnotatedWith(meta);
+ super(null, annotationItems);
}
+
+ @Override
+ public boolean isCachable()
+ {
+ return cachable;
+ }
}
}
Modified: projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/plugins/context/CachingMetaDataContext.java
===================================================================
--- projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/plugins/context/CachingMetaDataContext.java 2009-12-08 17:30:52 UTC (rev 97552)
+++ projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/plugins/context/CachingMetaDataContext.java 2009-12-08 17:36:49 UTC (rev 97553)
@@ -24,6 +24,7 @@
import java.lang.annotation.Annotation;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import org.jboss.metadata.plugins.cache.Cache;
import org.jboss.metadata.plugins.cache.CacheFactory;
@@ -60,10 +61,18 @@
/** All meta data */
private volatile CacheItem<MetaDatasItem> cachedMetaDatasItem;
+
+ /** The annotations indexed by their meta-annotations. The contained map is
+ * of type <Class<?>, AnnotationsItem> */
+ @SuppressWarnings("unchecked")
+ private volatile Cache<String, Map> cachedMetaAnnotations;
+
+ /** The key into cachedMetaAnnotations for the indexed meta-anotations*/
+ private static final String META_ANNOTATIONS_INDEX_KEY = "MetaAnnotations";
/** Cached components */
private volatile Cache<Signature, MetaDataRetrieval> cachedComponents;
-
+
/** The valid time */
private volatile long validTime;
@@ -189,6 +198,7 @@
{
clearCache(annotations);
clearCache(metaDataByName);
+ clearCache(cachedMetaAnnotations);
validTime = newValidTime;
}
@@ -213,6 +223,44 @@
return result;
}
+
+ @Override
+ @SuppressWarnings("unchecked")
+ protected Map<Class, AnnotationsItem> retrieveAnnotationsAnnotatedWithIndex()
+ {
+ long newValidTime = getValidTime().getValidTime();
+ if (validTime < newValidTime)
+ {
+ clearCache(annotations);
+ clearCache(metaDataByName);
+ clearCache(cachedMetaAnnotations);
+ validTime = newValidTime;
+ }
+
+ if (cachedMetaAnnotations == null)
+ cachedMetaAnnotations = factory.createCache(String.class, Map.class, getFqn());
+
+ Map<Class, AnnotationsItem> index = cachedMetaAnnotations.get(META_ANNOTATIONS_INDEX_KEY);
+ if (index != null)
+ {
+ for (AnnotationsItem item : index.values())
+ {
+ if (item.isValid() == false)
+ {
+ index = null;
+ break;
+ }
+ }
+ }
+ if (index == null)
+ {
+ index = super.retrieveAnnotationsAnnotatedWithIndex();
+ cachedMetaAnnotations.clear();
+ cachedMetaAnnotations.put(META_ANNOTATIONS_INDEX_KEY, index);
+ }
+
+ return index;
+ }
public MetaDatasItem retrieveMetaData()
{
@@ -241,6 +289,7 @@
{
clearCache(annotations);
clearCache(metaDataByName);
+ clearCache(cachedMetaAnnotations);
validTime = newValidTime;
}
@@ -276,6 +325,7 @@
{
clearCache(annotations);
clearCache(metaDataByName);
+ clearCache(cachedMetaAnnotations);
validTime = newValidTime;
}
Modified: projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/plugins/loader/AbstractMetaDataLoader.java
===================================================================
--- projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/plugins/loader/AbstractMetaDataLoader.java 2009-12-08 17:30:52 UTC (rev 97552)
+++ projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/plugins/loader/AbstractMetaDataLoader.java 2009-12-08 17:36:49 UTC (rev 97553)
@@ -57,7 +57,7 @@
/** The scope key */
private ScopeKey scopeKey;
- private volatile AnnotationsAnnotatedWithCache cache;
+ //private volatile AnnotationsAnnotatedWithCache cache;
/**
* Create a new AbstractMetaDataLoader.
@@ -97,45 +97,25 @@
{
return retrieveAnnotations();
}
-
- protected AnnotationsAnnotatedWithCache getAnnotationsAnnotatedWithCache()
- {
- if (cache == null)
- {
- synchronized (this)
- {
- if (cache == null)
- {
- cache = new AnnotationsAnnotatedWithCache();
- }
- }
- }
- return cache;
- }
@SuppressWarnings({"unchecked"})
public AnnotationsItem retrieveAnnotationsAnnotatedWith(Class<? extends Annotation> meta)
{
- AnnotationsItem item = getAnnotationsAnnotatedWithCache().getAnnotationsAnnotatedWith(meta);
- if (item == null)
+ AnnotationsItem annotations = retrieveAnnotations();
+ List<AnnotationItem<? extends Annotation>> values = new ArrayList<AnnotationItem<? extends Annotation>>();
+ for (AnnotationItem<? extends Annotation> current : annotations.getAnnotations())
{
- AnnotationsItem annotations = retrieveAnnotations();
- List<AnnotationItem<? extends Annotation>> values = new ArrayList<AnnotationItem<? extends Annotation>>();
- for (AnnotationItem<? extends Annotation> current : annotations.getAnnotations())
- {
- for (Annotation ann : current.getAnnotation().annotationType().getAnnotations())
+ for (Annotation ann : current.getAnnotation().annotationType().getAnnotations())
+ {
+ if (meta == ann.annotationType())
{
- if (meta == ann.annotationType())
- {
- values.add(current);
- break;
- }
+ values.add(current);
+ break;
}
}
- item = new BasicAnnotationsItem(this, values.toArray(new AnnotationItem[values.size()]));
- cache.addAnnotationsAnnotatedWith(meta, item);
}
- return item;
+
+ return new BasicAnnotationsItem(this, values.toArray(new AnnotationItem[values.size()]));
}
@@ -187,15 +167,5 @@
public void invalidate()
{
validTime.invalidate();
- invalidateAnnotationsAnnotatedWithCache();
}
-
- /**
- * Invalidate cache.
- */
- protected void invalidateAnnotationsAnnotatedWithCache()
- {
- if (cache != null)
- cache.invalidate();
- }
}
Modified: projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/plugins/loader/memory/MemoryMetaDataLoader.java
===================================================================
--- projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/plugins/loader/memory/MemoryMetaDataLoader.java 2009-12-08 17:30:52 UTC (rev 97552)
+++ projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/plugins/loader/memory/MemoryMetaDataLoader.java 2009-12-08 17:36:49 UTC (rev 97553)
@@ -186,7 +186,6 @@
annotation.invalidate();
invalidateAnnotationsItem();
invalidateMetaDatasItem();
- invalidateAnnotationsAnnotatedWithCache();
return annotation.getAnnotation();
}
Deleted: projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/spi/retrieval/cummulative/CummulativeAnnotationsFilter.java
===================================================================
--- projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/spi/retrieval/cummulative/CummulativeAnnotationsFilter.java 2009-12-08 17:30:52 UTC (rev 97552)
+++ projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/spi/retrieval/cummulative/CummulativeAnnotationsFilter.java 2009-12-08 17:36:49 UTC (rev 97553)
@@ -1,42 +0,0 @@
-/*
-* JBoss, Home of Professional Open Source.
-* Copyright 2006, Red Hat Middleware LLC, and individual contributors
-* as indicated by the @author tags. See the copyright.txt file in the
-* distribution for a full listing of individual contributors.
-*
-* This is free software; you can redistribute it and/or modify it
-* under the terms of the GNU Lesser General Public License as
-* published by the Free Software Foundation; either version 2.1 of
-* the License, or (at your option) any later version.
-*
-* This software is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-* Lesser General Public License for more details.
-*
-* You should have received a copy of the GNU Lesser General Public
-* License along with this software; if not, write to the Free
-* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
-* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
-*/
-package org.jboss.metadata.spi.retrieval.cummulative;
-
-import org.jboss.metadata.spi.retrieval.AnnotationsItem;
-import org.jboss.metadata.spi.retrieval.MetaDataRetrieval;
-
-/**
- * Annotations filter.
- *
- * @author <a href="kabir.khan at jboss.com">Kabir Khan</a>
- * @version $Revision: 1.1 $
- */
-public interface CummulativeAnnotationsFilter
-{
- /**
- * Get annotation items.
- *
- * @param retrieval the retrieval
- * @return matching annotation items
- */
- AnnotationsItem getAnnotations(MetaDataRetrieval retrieval);
-}
Modified: projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/spi/retrieval/cummulative/CummulativeAnnotationsItem.java
===================================================================
--- projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/spi/retrieval/cummulative/CummulativeAnnotationsItem.java 2009-12-08 17:30:52 UTC (rev 97552)
+++ projects/jboss-mdr/trunk/src/main/java/org/jboss/metadata/spi/retrieval/cummulative/CummulativeAnnotationsItem.java 2009-12-08 17:36:49 UTC (rev 97553)
@@ -49,8 +49,6 @@
/** The valid time */
private long validTime;
- private CummulativeAnnotationsFilter filter = AllAnnotationsFilter.INSTANCE;
-
/**
* Create a new CummulativeAnnotationsItem.
*
@@ -59,25 +57,11 @@
*/
public CummulativeAnnotationsItem(MetaDataContext context, boolean includeParent)
{
- this(context, includeParent, null);
- }
-
- /**
- * Create a new CummulativeAnnotationsItem.
- *
- * @param context the context
- * @param includeParent whether to include the parent
- * @param filter the annotations filter
- */
- public CummulativeAnnotationsItem(MetaDataContext context, boolean includeParent, CummulativeAnnotationsFilter filter)
- {
if (context == null)
throw new IllegalArgumentException("Null context");
this.context = context;
this.includeParent = includeParent;
- if (filter != null)
- this.filter = filter;
init(context.getValidTime().getValidTime());
}
@@ -148,7 +132,7 @@
for (MetaDataRetrieval retrieval : retrievals)
{
- AnnotationsItem item = filter.getAnnotations(retrieval);
+ AnnotationsItem item = retrieval.retrieveAnnotations();
if (item != null)
{
AnnotationItem<? extends Annotation>[] items = item.getAnnotations();
@@ -168,13 +152,4 @@
this.validTime = validTime;
}
- private static class AllAnnotationsFilter implements CummulativeAnnotationsFilter
- {
- private static final CummulativeAnnotationsFilter INSTANCE = new AllAnnotationsFilter();
-
- public AnnotationsItem getAnnotations(MetaDataRetrieval retrieval)
- {
- return retrieval.retrieveAnnotations();
- }
- }
}
Modified: projects/jboss-mdr/trunk/src/test/java/org/jboss/test/metadata/context/cache/test/SimpleCacheMetaDataContextUnitTestCase.java
===================================================================
--- projects/jboss-mdr/trunk/src/test/java/org/jboss/test/metadata/context/cache/test/SimpleCacheMetaDataContextUnitTestCase.java 2009-12-08 17:30:52 UTC (rev 97552)
+++ projects/jboss-mdr/trunk/src/test/java/org/jboss/test/metadata/context/cache/test/SimpleCacheMetaDataContextUnitTestCase.java 2009-12-08 17:36:49 UTC (rev 97553)
@@ -33,6 +33,8 @@
import org.jboss.metadata.spi.retrieval.basic.BasicAnnotationsItem;
import org.jboss.test.metadata.context.AbstractMetaDataContextTest;
import org.jboss.test.metadata.context.cache.support.TestMetaDataLoader;
+import org.jboss.test.metadata.shared.support.MetaAnnotation1;
+import org.jboss.test.metadata.shared.support.MetaAnnotation2;
import org.jboss.test.metadata.shared.support.TestAnnotation;
import org.jboss.test.metadata.shared.support.TestAnnotationImpl;
@@ -94,8 +96,15 @@
protected void testAnnotation(MetaData metaData, TestMetaDataLoader loader) throws Exception
{
+ //Internally this does not use CummulativeAnnotationsItem
assertNoAnnotation(metaData, TestAnnotation.class);
assertTrue(loader.isRetrieved());
+
+ //Internally this uses CummulativeAnnotationsItem
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class);
+ assertTrue(loader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation2.class);
+ assertFalse(loader.isRetrieved());
BasicAnnotationItem<TestAnnotation> annotationItem = createAnnotationItem(loader, new TestAnnotationImpl(), TestAnnotation.class);
setAnnotations(loader, annotationItem);
@@ -105,10 +114,25 @@
assertAnnotation(metaData, TestAnnotation.class);
assertFalse(loader.isRetrieved());
+ assertAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class, expectedAnnotations(TestAnnotation.class));
+ assertTrue(loader.isRetrieved());
+ assertAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class, expectedAnnotations(TestAnnotation.class));
+ assertFalse(loader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation2.class);
+ assertFalse(loader.isRetrieved());
+
loader.clear();
assertNoAnnotation(metaData, TestAnnotation.class);
assertTrue(loader.isRetrieved());
+
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class);
+ assertTrue(loader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class);
+ assertFalse(loader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation2.class);
+ assertFalse(loader.isRetrieved());
+
}
public void testAnnotationFirstChild() throws Exception
@@ -212,6 +236,100 @@
testBelowAnnotation(metaData, getFirstParent(), getSecondParent());
}
+ protected void testBelowAnnotationWith(MetaData metaData, TestMetaDataLoader aboveLoader, TestMetaDataLoader belowLoader, boolean sameLevel) throws Exception
+ {
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class);
+ assertTrue(aboveLoader.isRetrieved());
+ assertTrue(belowLoader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation2.class);
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+
+ BasicAnnotationItem<TestAnnotation> annotationItem = createAnnotationItem(aboveLoader, new TestAnnotationImpl(), TestAnnotation.class);
+ setAnnotations(aboveLoader, annotationItem);
+ assertAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class, expectedAnnotations(TestAnnotation.class));
+ assertTrue(aboveLoader.isRetrieved());
+ if (sameLevel)
+ assertTrue(belowLoader.isRetrieved());
+ else
+ assertFalse(belowLoader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation2.class);
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+
+ annotationItem = createAnnotationItem(belowLoader, new TestAnnotationImpl(), TestAnnotation.class);
+ setAnnotations(belowLoader, annotationItem);
+ assertAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class, expectedAnnotations(TestAnnotation.class));
+ assertTrue(aboveLoader.isRetrieved());
+ assertTrue(belowLoader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation2.class);
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+
+ annotationItem.invalidate();
+ assertAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class, expectedAnnotations(TestAnnotation.class));
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation2.class);
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+
+ belowLoader.clear();
+ assertAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class, expectedAnnotations(TestAnnotation.class));
+ assertTrue(aboveLoader.isRetrieved());
+ assertTrue(belowLoader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation2.class);
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+
+ aboveLoader.clear();
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class);
+ assertTrue(aboveLoader.isRetrieved());
+ if (sameLevel)
+ assertTrue(belowLoader.isRetrieved());
+ else
+ assertFalse(belowLoader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation2.class);
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+ }
+
+ public void testBelowAnnotationWithFirstChildSecondChild() throws Exception
+ {
+ MetaData metaData = createTestContext();
+ testBelowAnnotationWith(metaData, getFirstChild(), getSecondChild(), true);
+ }
+
+ public void testBelowAnnotationWithFirstChildFirstParent() throws Exception
+ {
+ MetaData metaData = createTestContext();
+ testBelowAnnotationWith(metaData, getFirstChild(), getFirstParent(), false);
+ }
+
+ public void testBelowAnnotationWithFirstChildSecondParent() throws Exception
+ {
+ MetaData metaData = createTestContext();
+ testBelowAnnotationWith(metaData, getFirstChild(), getSecondParent(), false);
+ }
+
+ public void testBelowAnnotationWithSecondChildFirstParent() throws Exception
+ {
+ MetaData metaData = createTestContext();
+ testBelowAnnotationWith(metaData, getSecondChild(), getFirstParent(), false);
+ }
+
+ public void testBelowAnnotationWithSecondChildSecondParent() throws Exception
+ {
+ MetaData metaData = createTestContext();
+ testBelowAnnotationWith(metaData, getSecondChild(), getSecondParent(), false);
+ }
+
+ public void testBelowAnnotationWithFirstParentSecondParent() throws Exception
+ {
+ MetaData metaData = createTestContext();
+ testBelowAnnotationWith(metaData, getFirstParent(), getSecondParent(), true);
+ }
+
protected void testAboveAnnotation(MetaData metaData, TestMetaDataLoader aboveLoader, TestMetaDataLoader belowLoader) throws Exception
{
assertNoAnnotation(metaData, TestAnnotation.class);
@@ -261,6 +379,7 @@
assertNoAnnotation(metaData, TestAnnotation.class);
assertTrue(aboveLoader.isRetrieved());
assertTrue(belowLoader.isRetrieved());
+
}
public void testAboveAnnotationFirstChildSecondChild() throws Exception
@@ -298,4 +417,127 @@
MetaData metaData = createTestContext();
testAboveAnnotation(metaData, getFirstParent(), getSecondParent());
}
+
+ protected void testAboveAnnotationWith(MetaData metaData, TestMetaDataLoader aboveLoader, TestMetaDataLoader belowLoader, boolean sameLevel) throws Exception
+ {
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class);
+ assertTrue(aboveLoader.isRetrieved());
+ assertTrue(belowLoader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation2.class);
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+
+ BasicAnnotationItem<TestAnnotation> annotationItem = createAnnotationItem(belowLoader, new TestAnnotationImpl(), TestAnnotation.class);
+ setAnnotations(belowLoader, annotationItem);
+
+ assertAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class, expectedAnnotations(TestAnnotation.class));
+ assertTrue(aboveLoader.isRetrieved());
+ assertTrue(belowLoader.isRetrieved());
+ assertAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class, expectedAnnotations(TestAnnotation.class));
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation2.class);
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+
+ annotationItem = createAnnotationItem(aboveLoader, new TestAnnotationImpl(), TestAnnotation.class);
+ setAnnotations(aboveLoader, annotationItem);
+ assertAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class, expectedAnnotations(TestAnnotation.class));
+ assertTrue(aboveLoader.isRetrieved());
+ if (sameLevel)
+ assertTrue(belowLoader.isRetrieved());
+ else
+ assertFalse(belowLoader.isRetrieved());
+ assertAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class, expectedAnnotations(TestAnnotation.class));
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation2.class);
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+
+ belowLoader.clear();
+ assertAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class, expectedAnnotations(TestAnnotation.class));
+ assertTrue(aboveLoader.isRetrieved());
+ assertTrue(belowLoader.isRetrieved());
+ assertAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class, expectedAnnotations(TestAnnotation.class));
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation2.class);
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+
+ annotationItem = createAnnotationItem(belowLoader, new TestAnnotationImpl(), TestAnnotation.class);
+ setAnnotations(belowLoader, annotationItem);
+
+ assertAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class, expectedAnnotations(TestAnnotation.class));
+ assertTrue(aboveLoader.isRetrieved());
+ assertTrue(belowLoader.isRetrieved());
+ assertAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class, expectedAnnotations(TestAnnotation.class));
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation2.class);
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+
+ aboveLoader.clear();
+ assertAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class, expectedAnnotations(TestAnnotation.class));
+ assertTrue(aboveLoader.isRetrieved());
+ if (sameLevel)
+ assertTrue(belowLoader.isRetrieved());
+ else
+ assertFalse(belowLoader.isRetrieved());
+ assertAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class, expectedAnnotations(TestAnnotation.class));
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation2.class);
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+
+ belowLoader.clear();
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class);
+ assertTrue(aboveLoader.isRetrieved());
+ assertTrue(belowLoader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation1.class);
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+ assertNoAnnotationsAnnotatedWith(metaData, MetaAnnotation2.class);
+ assertFalse(aboveLoader.isRetrieved());
+ assertFalse(belowLoader.isRetrieved());
+ }
+
+ public void testAboveAnnotationWithFirstChildSecondChild() throws Exception
+ {
+ MetaData metaData = createTestContext();
+ testAboveAnnotationWith(metaData, getFirstChild(), getSecondChild(), true);
+ }
+
+ public void testAboveAnnotationWithFirstChildFirstParent() throws Exception
+ {
+ MetaData metaData = createTestContext();
+ testAboveAnnotationWith(metaData, getFirstChild(), getFirstParent(), false);
+ }
+
+ public void testAboveAnnotationWithFirstChildSecondParent() throws Exception
+ {
+ MetaData metaData = createTestContext();
+ testAboveAnnotationWith(metaData, getFirstChild(), getSecondParent(), false);
+ }
+
+ public void testAboveAnnotationWithSecondChildFirstParent() throws Exception
+ {
+ MetaData metaData = createTestContext();
+ testAboveAnnotationWith(metaData, getSecondChild(), getFirstParent(), false);
+ }
+
+ public void testAboveAnnotationWithSecondChildSecondParent() throws Exception
+ {
+ MetaData metaData = createTestContext();
+ testAboveAnnotationWith(metaData, getSecondChild(), getSecondParent(), false);
+ }
+
+ public void testAboveAnnotationWithFirstParentSecondParent() throws Exception
+ {
+ MetaData metaData = createTestContext();
+ testAboveAnnotationWith(metaData, getFirstParent(), getSecondParent(), true);
+ }
}
More information about the jboss-cvs-commits
mailing list