Author: pete.muir(a)jboss.org Date: 2010-01-27 19:22:07 -0500 (Wed, 27 Jan 2010) New Revision: 5647 Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Clothes.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Coins.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/HotAir.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/InjectLiteral.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Original.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Plug.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/RunningTime.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/SerialNumber.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Special.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/SpecialLiteral.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/TumbleDryer.java Modified: core/trunk/impl/src/main/java/org/jboss/weld/exceptions/WeldException.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java core/trunk/impl/src/main/java/org/jboss/weld/util/Beans.java core/trunk/impl/src/main/java/org/jboss/weld/util/reflection/Reflections.java core/trunk/impl/src/main/resources/org/jboss/weld/messages/util_en.properties core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtension.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtensionTest.java Log: WELD-372, still needs work on verifying parameters Modified: core/trunk/impl/src/main/java/org/jboss/weld/exceptions/WeldException.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/exceptions/WeldException.java 2010-01-27 20:25:08 UTC (rev 5646) +++ core/trunk/impl/src/main/java/org/jboss/weld/exceptions/WeldException.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -80,14 +80,16 @@ { super(); StringBuilder errorMessage = new StringBuilder(); - boolean firstError = true; + int i = 0;; for (Throwable throwable : errors) { - if (!firstError) + if (i > 0) { errorMessage.append('\n'); } + errorMessage.append("Exception #").append(i).append(" :"); errorMessage.append(throwable.getLocalizedMessage()); + i++; } this.message = new WeldExceptionMessage(errorMessage.toString()); } Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java 2010-01-27 20:25:08 UTC (rev 5646) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -23,6 +23,7 @@ import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.lang.reflect.Type; +import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; @@ -35,6 +36,7 @@ import javax.enterprise.inject.spi.AnnotatedConstructor; import javax.enterprise.inject.spi.AnnotatedField; import javax.enterprise.inject.spi.AnnotatedMethod; +import javax.enterprise.inject.spi.AnnotatedParameter; import javax.enterprise.inject.spi.AnnotatedType; import org.jboss.weld.bootstrap.events.ExternalAnnotatedType; @@ -66,7 +68,19 @@ */ public class WeldClassImpl<T> extends AbstractWeldAnnotated<T, Class<T>> implements WeldClass<T> { - + + private static <T> void mapConstructorAnnotations(SetMultimap<Class<? extends Annotation>, WeldConstructor<T>> annotatedConstructors, WeldConstructor<T> annotatedConstructor) + { + for (Annotation annotation : annotatedConstructor.getAnnotations()) + { + if (!annotatedConstructors.containsKey(annotation.annotationType())) + { + annotatedConstructors.putAll(annotation.annotationType(), new HashSet<WeldConstructor<T>>()); + } + annotatedConstructors.get(annotation.annotationType()).add(annotatedConstructor); + } + } + // Class attributes private final WeldClass<?> superclass; @@ -104,7 +118,7 @@ private final SetMultimap<Class<? extends Annotation>, WeldConstructor<T>> annotatedConstructors; // The map from class list to abstracted constructor private final Map<List<Class<?>>, WeldConstructor<T>> constructorsByArgumentMap; - + // The meta-annotation map (annotation type -> set of annotations containing // meta-annotation) of the item private final SetMultimap<Class<? extends Annotation>, Annotation> declaredMetaAnnotationMap; @@ -156,51 +170,60 @@ this.declaredAnnotatedFields = Multimaps.newSetMultimap(new HashMap<Class<? extends Annotation>, Collection<WeldField<?, T>>>(), HashSetSupplier.<WeldField<?, T>> instance()); this.declaredMetaAnnotatedFields = Multimaps.newSetMultimap(new HashMap<Class<? extends Annotation>, Collection<WeldField<?, ?>>>(), HashSetSupplier.<WeldField<?, ?>> instance()); - Map<Field, AnnotatedField<? super T>> annotatedTypeFields = new HashMap<Field, AnnotatedField<? super T>>(); - if (annotatedType != null) + if (annotatedType == null) { - for (AnnotatedField<? super T> annotatedField : annotatedType.getFields()) + for (Class<?> c = rawType; c != Object.class && c != null; c = c.getSuperclass()) { - annotatedTypeFields.put(annotatedField.getJavaMember(), annotatedField); + for (Field field : SecureReflections.getDeclaredFields(c)) + { + WeldField<?, T> annotatedField = WeldFieldImpl.of(field, this.<T> getDeclaringWeldClass(field, classTransformer), classTransformer); + this.fields.add(annotatedField); + if (c == rawType) + { + this.declaredFields.add(annotatedField); + this.declaredFieldsByName.put(annotatedField.getName(), annotatedField); + } + for (Annotation annotation : annotatedField.getAnnotations()) + { + this.annotatedFields.put(annotation.annotationType(), annotatedField); + if (c == rawType) + { + this.declaredAnnotatedFields.put(annotation.annotationType(), annotatedField); + } + for (Annotation metaAnnotation : annotation.annotationType().getAnnotations()) + { + if (c == rawType) + { + this.declaredMetaAnnotatedFields.put(metaAnnotation.annotationType(), annotatedField); + } + } + } + } } } - - for (Class<?> c = rawType; c != Object.class && c != null; c = c.getSuperclass()) + else { - for (Field field : SecureReflections.getDeclaredFields(c)) + for (AnnotatedField<? super T> field : annotatedType.getFields()) { - WeldField<?, T> annotatedField = null; - if (annotatedTypeFields.containsKey(field)) + WeldField<?, T> weldField = WeldFieldImpl.of(field, this.<T> getDeclaringWeldClass(field.getJavaMember(), classTransformer), classTransformer); + this.fields.add(weldField); + if (field.getDeclaringType().getJavaClass() == rawType) { - annotatedField = WeldFieldImpl.of(annotatedTypeFields.get(field), this.<T> getDeclaringWBClass(field, classTransformer), classTransformer); + this.declaredFields.add(weldField); + this.declaredFieldsByName.put(weldField.getName(), weldField); } - else + for (Annotation annotation : weldField.getAnnotations()) { - annotatedField = WeldFieldImpl.of(field, this.<T> getDeclaringWBClass(field, classTransformer), classTransformer); - } - - this.fields.add(annotatedField); - if (c == rawType) - { - this.declaredFields.add(annotatedField); - this.declaredFieldsByName.put(annotatedField.getName(), annotatedField); - } - for (Annotation annotation : annotatedField.getAnnotations()) - { - this.annotatedFields.put(annotation.annotationType(), annotatedField); - if (c == rawType) + this.annotatedFields.put(annotation.annotationType(), weldField); + if (field.getDeclaringType().getJavaClass() == rawType) { - this.declaredAnnotatedFields.put(annotation.annotationType(), annotatedField); - } - for (Annotation metaAnnotation : annotation.annotationType().getAnnotations()) - { - if (c == rawType) + this.declaredAnnotatedFields.put(annotation.annotationType(), weldField); + for (Annotation metaAnnotation : annotation.annotationType().getAnnotations()) { - this.declaredMetaAnnotatedFields.put(metaAnnotation.annotationType(), annotatedField); + this.declaredMetaAnnotatedFields.put(metaAnnotation.annotationType(), weldField); } } } - } } @@ -209,43 +232,38 @@ this.constructorsByArgumentMap = new HashMap<List<Class<?>>, WeldConstructor<T>>(); this.annotatedConstructors = Multimaps.newSetMultimap(new HashMap<Class<? extends Annotation>, Collection<WeldConstructor<T>>>(), HashSetSupplier.<WeldConstructor<T>> instance()); - Map<Constructor<? super T>, AnnotatedConstructor<T>> annotatedTypeConstructors = new HashMap<Constructor<? super T>, AnnotatedConstructor<T>>(); - if (annotatedType != null) + this.declaredConstructorsBySignature = new HashMap<ConstructorSignature, WeldConstructor<?>>(); + if (annotatedType == null) { - for (AnnotatedConstructor<T> annotated : annotatedType.getConstructors()) + for (Constructor<?> constructor : SecureReflections.getDeclaredConstructors(rawType)) { - annotatedTypeConstructors.put(annotated.getJavaMember(), annotated); + @SuppressWarnings("unchecked") + Constructor<T> c = (Constructor<T>) constructor; + + WeldConstructor<T> annotatedConstructor = WeldConstructorImpl.of(c, this.<T> getDeclaringWeldClass(c, classTransformer), classTransformer); + this.constructors.add(annotatedConstructor); + this.constructorsByArgumentMap.put(Arrays.asList(constructor.getParameterTypes()), annotatedConstructor); + this.declaredConstructorsBySignature.put(annotatedConstructor.getSignature(), annotatedConstructor); + mapConstructorAnnotations(annotatedConstructors, annotatedConstructor); } } - - this.declaredConstructorsBySignature = new HashMap<ConstructorSignature, WeldConstructor<?>>(); - for (Constructor<?> constructor : SecureReflections.getDeclaredConstructors(rawType)) + else { - WeldConstructor<T> annotatedConstructor = null; - if (annotatedTypeConstructors.containsKey(constructor)) + for (AnnotatedConstructor<T> constructor : annotatedType.getConstructors()) { - WeldClass<T> declaringClass = this.getDeclaringWBClass(constructor, classTransformer); - annotatedConstructor = WeldConstructorImpl.of(annotatedTypeConstructors.get(constructor), declaringClass, classTransformer); - } - else - { - // TODO Fix this cast - Constructor<T> c = (Constructor<T>) constructor; - annotatedConstructor = WeldConstructorImpl.of(c, this.<T> getDeclaringWBClass(c, classTransformer), classTransformer); - } + WeldClass<T> declaringClass = this.getDeclaringWeldClass(constructor.getJavaMember(), classTransformer); + WeldConstructor<T> weldConstructor = WeldConstructorImpl.of(constructor, declaringClass, classTransformer); - this.constructors.add(annotatedConstructor); - this.constructorsByArgumentMap.put(Arrays.asList(constructor.getParameterTypes()), annotatedConstructor); + this.constructors.add(weldConstructor); - this.declaredConstructorsBySignature.put(annotatedConstructor.getSignature(), annotatedConstructor); - - for (Annotation annotation : annotatedConstructor.getAnnotations()) - { - if (!annotatedConstructors.containsKey(annotation.annotationType())) + List<Class<?>> parameterTypes = new ArrayList<Class<?>>(); + for (AnnotatedParameter<T> parameter : constructor.getParameters()) { - annotatedConstructors.putAll(annotation.annotationType(), new HashSet<WeldConstructor<T>>()); + parameterTypes.add(Reflections.getRawType(parameter.getBaseType())); } - annotatedConstructors.get(annotation.annotationType()).add(annotatedConstructor); + this.constructorsByArgumentMap.put(parameterTypes, weldConstructor); + this.declaredConstructorsBySignature.put(weldConstructor.getSignature(), weldConstructor); + mapConstructorAnnotations(annotatedConstructors, weldConstructor); } } @@ -258,57 +276,75 @@ this.declaredMethodsBySignature = new HashMap<MethodSignature, WeldMethod<?, ?>>(); this.methodsBySignature = new HashMap<MethodSignature, WeldMethod<?, ?>>(); - Map<Method, AnnotatedMethod<?>> annotatedTypeMethods = new HashMap<Method, AnnotatedMethod<?>>(); - if (annotatedType != null) + if (annotatedType == null) { - for (AnnotatedMethod<?> annotated : annotatedType.getMethods()) + for (Class<?> c = rawType; c != Object.class && c != null; c = c.getSuperclass()) { - annotatedTypeMethods.put(annotated.getJavaMember(), annotated); + for (Method method : SecureReflections.getDeclaredMethods(c)) + { + WeldMethod<?, T> weldMethod = WeldMethodImpl.of(method, this.<T> getDeclaringWeldClass(method, classTransformer), classTransformer); + this.methods.add(weldMethod); + this.methodsBySignature.put(weldMethod.getSignature(), weldMethod); + if (c == rawType) + { + this.declaredMethods.add(weldMethod); + this.declaredMethodsBySignature.put(weldMethod.getSignature(), weldMethod); + } + for (Annotation annotation : weldMethod.getAnnotations()) + { + annotatedMethods.put(annotation.annotationType(), weldMethod); + if (c == rawType) + { + this.declaredAnnotatedMethods.put(annotation.annotationType(), weldMethod); + } + } + for (Class<? extends Annotation> annotationType : WeldMethod.MAPPED_PARAMETER_ANNOTATIONS) + { + if (weldMethod.getWeldParameters(annotationType).size() > 0) + { + if (c == rawType) + { + this.declaredMethodsByAnnotatedParameters.put(annotationType, weldMethod); + } + } + } + } } } - - for (Class<?> c = rawType; c != Object.class && c != null; c = c.getSuperclass()) + else { - for (Method method : SecureReflections.getDeclaredMethods(c)) + for (AnnotatedMethod<? super T> method : annotatedType.getMethods()) { - WeldMethod<?, T> annotatedMethod = null; - if (annotatedTypeMethods.containsKey(method)) + WeldMethod<?, T> weldMethod = WeldMethodImpl.of(method, this, classTransformer); + this.methods.add(weldMethod); + this.methodsBySignature.put(weldMethod.getSignature(), weldMethod); + if (method.getDeclaringType().getJavaClass() == rawType) { - annotatedMethod = WeldMethodImpl.of(annotatedTypeMethods.get(method), this, classTransformer); + this.declaredMethods.add(weldMethod); + this.declaredMethodsBySignature.put(weldMethod.getSignature(), weldMethod); } - else + for (Annotation annotation : weldMethod.getAnnotations()) { - annotatedMethod = WeldMethodImpl.of(method, this.<T> getDeclaringWBClass(method, classTransformer), classTransformer); - } - this.methods.add(annotatedMethod); - this.methodsBySignature.put(annotatedMethod.getSignature(), annotatedMethod); - if (c == rawType) - { - this.declaredMethods.add(annotatedMethod); - this.declaredMethodsBySignature.put(annotatedMethod.getSignature(), annotatedMethod); - } - for (Annotation annotation : annotatedMethod.getAnnotations()) - { - annotatedMethods.put(annotation.annotationType(), annotatedMethod); - if (c == rawType) + annotatedMethods.put(annotation.annotationType(), weldMethod); + if (method.getDeclaringType().getJavaClass() == rawType) { - this.declaredAnnotatedMethods.put(annotation.annotationType(), annotatedMethod); + this.declaredAnnotatedMethods.put(annotation.annotationType(), weldMethod); } } for (Class<? extends Annotation> annotationType : WeldMethod.MAPPED_PARAMETER_ANNOTATIONS) { - if (annotatedMethod.getWeldParameters(annotationType).size() > 0) + if (weldMethod.getWeldParameters(annotationType).size() > 0) { - if (c == rawType) + if (method.getDeclaringType().getJavaClass() == rawType) { - this.declaredMethodsByAnnotatedParameters.put(annotationType, annotatedMethod); + this.declaredMethodsByAnnotatedParameters.put(annotationType, weldMethod); } } } } } - - this.declaredMetaAnnotationMap = Multimaps.newSetMultimap(new HashMap<Class<? extends Annotation>, Collection<Annotation>>(), HashSetSupplier.<Annotation>instance()); + + this.declaredMetaAnnotationMap = Multimaps.newSetMultimap(new HashMap<Class<? extends Annotation>, Collection<Annotation>>(), HashSetSupplier.<Annotation> instance()); for (Annotation declaredAnnotation : declaredAnnotationMap.values()) { addMetaAnnotations(declaredMetaAnnotationMap, declaredAnnotation, declaredAnnotation.annotationType().getAnnotations(), true); @@ -318,7 +354,7 @@ } @SuppressWarnings("unchecked") - private <X> WeldClass<X> getDeclaringWBClass(Member member, ClassTransformer transformer) + private <X> WeldClass<X> getDeclaringWeldClass(Member member, ClassTransformer transformer) { if (member.getDeclaringClass().equals(getJavaClass())) { @@ -636,7 +672,7 @@ { return (Set) methods; } - + public Set<Annotation> getDeclaredMetaAnnotations(Class<? extends Annotation> metaAnnotationType) { return Collections.unmodifiableSet(declaredMetaAnnotationMap.get(metaAnnotationType)); Modified: core/trunk/impl/src/main/java/org/jboss/weld/util/Beans.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/util/Beans.java 2010-01-27 20:25:08 UTC (rev 5646) +++ core/trunk/impl/src/main/java/org/jboss/weld/util/Beans.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -672,7 +672,7 @@ { if (initializerAnnotatedConstructors.size() > 1) { - throw new DefinitionException(AMBIGUOUS_CONSTRUCTOR, type); + throw new DefinitionException(AMBIGUOUS_CONSTRUCTOR, type, initializerAnnotatedConstructors); } } else if (initializerAnnotatedConstructors.size() == 1) Modified: core/trunk/impl/src/main/java/org/jboss/weld/util/reflection/Reflections.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/util/reflection/Reflections.java 2010-01-27 20:25:08 UTC (rev 5646) +++ core/trunk/impl/src/main/java/org/jboss/weld/util/reflection/Reflections.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -635,5 +635,22 @@ { return clazz.isPrimitive() || Serializable.class.isAssignableFrom(clazz); } + + @SuppressWarnings("unchecked") + public static <T> Class<T> getRawType(Type type) + { + if (type instanceof Class<?>) + { + return (Class<T>) type; + } + else if (type instanceof ParameterizedType) + { + if (((ParameterizedType) type).getRawType() instanceof Class<?>) + { + return (Class<T>) ((ParameterizedType) type).getRawType(); + } + } + return null; + } } Modified: core/trunk/impl/src/main/resources/org/jboss/weld/messages/util_en.properties =================================================================== --- core/trunk/impl/src/main/resources/org/jboss/weld/messages/util_en.properties 2010-01-27 20:25:08 UTC (rev 5646) +++ core/trunk/impl/src/main/resources/org/jboss/weld/messages/util_en.properties 2010-01-28 00:22:07 UTC (rev 5647) @@ -10,8 +10,8 @@ INITIALIZER_CANNOT_BE_OBSERVER=Initializer method {0} cannot be annotated @Observes on {1} QUALIFIER_ON_FINAL_FIELD=Cannot place qualifiers on final fields: {0} TOO_MANY_INITIALIZERS=Cannot have more than one constructor annotated with @Initializer for {0} -AMBIGUOUS_CONSTRUCTOR=Cannot determine constructor to use for {0} -INVALID_QUANTITY_INJECTABLE_FIELDS_AND_INITIALIZER_METHODS=injectableFields and initializerMethods must have the same size.\\n\\nInjectable Fields: {0}\\nInitializerMethods: {1} +AMBIGUOUS_CONSTRUCTOR=Cannot determine constructor to use for {0}. Possible constructors {1} +INVALID_QUANTITY_INJECTABLE_FIELDS_AND_INITIALIZER_METHODS=injectableFields and initializerMethods must have the same size.\\n\\nInjectable Fields\: {0}\\nInitializerMethods\: {1} ANNOTATION_NOT_QUALIFIER=Annotation {0} is not a qualifier REDUNDANT_QUALIFIER=Qualifier {0} is already present in the set {1} UNABLE_TO_FIND_CONSTRUCTOR=Cannot determine constructor to use for {0} Modified: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtension.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtension.java 2010-01-27 20:25:08 UTC (rev 5646) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtension.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -17,36 +17,435 @@ package org.jboss.weld.tests.extensions.annotatedType; import java.lang.annotation.Annotation; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.Method; import java.lang.reflect.Type; +import java.util.ArrayList; import java.util.Collections; import java.util.HashSet; +import java.util.List; import java.util.Set; import javax.enterprise.event.Observes; +import javax.enterprise.inject.spi.AnnotatedCallable; import javax.enterprise.inject.spi.AnnotatedConstructor; import javax.enterprise.inject.spi.AnnotatedField; import javax.enterprise.inject.spi.AnnotatedMethod; +import javax.enterprise.inject.spi.AnnotatedParameter; import javax.enterprise.inject.spi.AnnotatedType; import javax.enterprise.inject.spi.BeforeBeanDiscovery; import javax.enterprise.inject.spi.Extension; +import javax.inject.Inject; import org.jboss.weld.tests.extensions.annotatedType.EcoFriendlyWashingMachine.EcoFriendlyWashingMachineLiteral; +import org.jboss.weld.util.collections.Arrays2; public class AnnotatedTypeExtension implements Extension { + public void addTumbleDryer(@Observes BeforeBeanDiscovery beforeBeanDiscovery) + { + + final Set<AnnotatedConstructor<TumbleDryer>> constructors = new HashSet<AnnotatedConstructor<TumbleDryer>>(); + final Set<AnnotatedField<? super TumbleDryer>> fields = new HashSet<AnnotatedField<? super TumbleDryer>>(); + final Set<AnnotatedMethod<? super TumbleDryer>> methods = new HashSet<AnnotatedMethod<? super TumbleDryer>>(); + + final AnnotatedType<TumbleDryer> tumbleDryer = new AnnotatedType<TumbleDryer>() + { + + public Set<AnnotatedConstructor<TumbleDryer>> getConstructors() + { + return constructors; + } + + public Set<AnnotatedField<? super TumbleDryer>> getFields() + { + return fields; + } + + public Set<AnnotatedMethod<? super TumbleDryer>> getMethods() + { + return methods; + } + + // Now the easy stuff + + public Class<TumbleDryer> getJavaClass() + { + return TumbleDryer.class; + } + + public <T extends Annotation> T getAnnotation(Class<T> annotationType) + { + // Class has no annotations + return null; + } + + public Set<Annotation> getAnnotations() + { + return Collections.emptySet(); + } + + public Type getBaseType() + { + return TumbleDryer.class; + } + + public Set<Type> getTypeClosure() + { + return Arrays2.<Type>asSet(TumbleDryer.class, Object.class); + } + + public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) + { + // Class has no annotations + return false; + } + + }; + + AnnotatedField<TumbleDryer> plug = new AnnotatedField<TumbleDryer>() + { + + public Field getJavaMember() + { + try + { + return TumbleDryer.class.getDeclaredField("plug"); + } + catch (NoSuchFieldException e) + { + throw new RuntimeException(e); + } + } + + public boolean isStatic() + { + return false; + } + + public <T extends Annotation> T getAnnotation(Class<T> annotationType) + { + if (annotationType.equals(Inject.class)) + { + return annotationType.cast(InjectLiteral.INSTANCE); + } + else if (annotationType.equals(Special.class)) + { + return annotationType.cast(SpecialLiteral.INSTANCE); + } + else + { + return null; + } + } + + public Set<Annotation> getAnnotations() + { + return Arrays2.asSet(InjectLiteral.INSTANCE, SpecialLiteral.INSTANCE); + } + + public Type getBaseType() + { + return Plug.class; + } + + public Set<Type> getTypeClosure() + { + return Arrays2.<Type>asSet(Plug.class, Object.class); + } + + public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) + { + if (annotationType.equals(Inject.class) || annotationType.equals(Special.class)) + { + return true; + } + else + { + return false; + } + } + + public AnnotatedType<TumbleDryer> getDeclaringType() + { + return tumbleDryer; + } + }; + fields.add(plug); + + + final List<AnnotatedParameter<TumbleDryer>> runningTimeParameters = new ArrayList<AnnotatedParameter<TumbleDryer>>(); + final AnnotatedMethod<TumbleDryer> runningTimeMethod = new AnnotatedMethod<TumbleDryer>() + { + + public Method getJavaMember() + { + try + { + return TumbleDryer.class.getDeclaredMethod("setRunningTime", RunningTime.class); + } + catch (NoSuchMethodException e) + { + throw new RuntimeException(e); + } + } + + public List<AnnotatedParameter<TumbleDryer>> getParameters() + { + return runningTimeParameters; + } + + public AnnotatedType<TumbleDryer> getDeclaringType() + { + return tumbleDryer; + } + + public boolean isStatic() + { + return false; + } + + public <T extends Annotation> T getAnnotation(Class<T> annotationType) + { + if (annotationType.equals(Inject.class)) + { + return annotationType.cast(InjectLiteral.INSTANCE); + } + else + { + return null; + } + } + + public Set<Annotation> getAnnotations() + { + return Collections.<Annotation>singleton(InjectLiteral.INSTANCE); + } + + public Type getBaseType() + { + return TumbleDryer.class; + } + + public Set<Type> getTypeClosure() + { + return Arrays2.<Type>asSet(TumbleDryer.class, Object.class); + } + + public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) + { + if (annotationType.equals(Inject.class)) + { + return true; + } + else + { + return false; + } + } + + }; + methods.add(runningTimeMethod); + + final AnnotatedParameter<TumbleDryer> runningTimeParameter = new AnnotatedParameter<TumbleDryer>() + { + + public AnnotatedCallable<TumbleDryer> getDeclaringCallable() + { + return runningTimeMethod; + } + + public int getPosition() + { + return 0; + } + + public <T extends Annotation> T getAnnotation(Class<T> annotationType) + { + if (annotationType.equals(Special.class)) + { + return annotationType.cast(SpecialLiteral.INSTANCE); + } + else + { + return null; + } + } + + public Set<Annotation> getAnnotations() + { + return Collections.<Annotation>singleton(SpecialLiteral.INSTANCE); + } + + public Type getBaseType() + { + return RunningTime.class; + } + + public Set<Type> getTypeClosure() + { + return Collections.<Type>singleton(RunningTime.class); + } + + public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) + { + if (annotationType.equals(Special.class)) + { + return true; + } + else + { + return false; + } + } + }; + runningTimeParameters.add(runningTimeParameter); + + final List<AnnotatedParameter<TumbleDryer>> clothesParameters = new ArrayList<AnnotatedParameter<TumbleDryer>>(); + final AnnotatedConstructor<TumbleDryer> clothesConstructor = new AnnotatedConstructor<TumbleDryer>() + { + + public Constructor<TumbleDryer> getJavaMember() + { + try + { + return TumbleDryer.class.getDeclaredConstructor(Clothes.class); + } + catch (NoSuchMethodException e) + { + throw new RuntimeException(e); + } + } + + public List<AnnotatedParameter<TumbleDryer>> getParameters() + { + return clothesParameters; + } + + public AnnotatedType<TumbleDryer> getDeclaringType() + { + return tumbleDryer; + } + + public boolean isStatic() + { + return false; + } + + public <T extends Annotation> T getAnnotation(Class<T> annotationType) + { + if (annotationType.equals(Inject.class)) + { + return annotationType.cast(InjectLiteral.INSTANCE); + } + else + { + return null; + } + } + + public Set<Annotation> getAnnotations() + { + return Collections.<Annotation>singleton(InjectLiteral.INSTANCE); + } + + public Type getBaseType() + { + return TumbleDryer.class; + } + + public Set<Type> getTypeClosure() + { + return Arrays2.<Type>asSet(TumbleDryer.class, Object.class); + } + + public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) + { + if (annotationType.equals(Inject.class)) + { + return true; + } + else + { + return false; + } + } + }; + constructors.add(clothesConstructor); + + AnnotatedParameter<TumbleDryer> clothesParameter = new AnnotatedParameter<TumbleDryer>() + { + + public AnnotatedCallable<TumbleDryer> getDeclaringCallable() + { + return clothesConstructor; + } + + public int getPosition() + { + return 0; + } + + + public <T extends Annotation> T getAnnotation(Class<T> annotationType) + { + if (annotationType.equals(Special.class)) + { + return annotationType.cast(SpecialLiteral.INSTANCE); + } + else + { + return null; + } + } + + public Set<Annotation> getAnnotations() + { + return Collections.<Annotation>singleton(SpecialLiteral.INSTANCE); + } + + public Type getBaseType() + { + return Clothes.class; + } + + public Set<Type> getTypeClosure() + { + return Arrays2.<Type>asSet(Clothes.class, Object.class); + } + + public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) + { + if (annotationType.equals(Special.class)) + { + return true; + } + else + { + return false; + } + } + }; + clothesParameters.add(clothesParameter); + + beforeBeanDiscovery.addAnnotatedType(tumbleDryer); + } + /** * Adds an eco friendly wasing machine * @param beforeBeanDiscovery */ public void addWashingMachine(@Observes BeforeBeanDiscovery beforeBeanDiscovery) { - beforeBeanDiscovery.addAnnotatedType(new AnnotatedType<WashingMachine>() + final Set<AnnotatedConstructor<WashingMachine>> constructors = new HashSet<AnnotatedConstructor<WashingMachine>>(); + final AnnotatedType<WashingMachine> type = new AnnotatedType<WashingMachine>() { public Set<AnnotatedConstructor<WashingMachine>> getConstructors() { - return Collections.emptySet(); + return constructors; } public Set<AnnotatedField<? super WashingMachine>> getFields() @@ -85,10 +484,7 @@ public Set<Type> getTypeClosure() { - Set<Type> ret = new HashSet<Type>(); - ret.add(Object.class); - ret.add(WashingMachine.class); - return ret; + return Arrays2.<Type>asSet(WashingMachine.class, Object.class); } public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) @@ -96,6 +492,65 @@ return annotationType == EcoFriendlyWashingMachine.class; } - }); + }; + + final AnnotatedConstructor<WashingMachine> constructor = new AnnotatedConstructor<WashingMachine>() + { + + public Constructor<WashingMachine> getJavaMember() + { + try + { + return WashingMachine.class.getDeclaredConstructor(); + } + catch (NoSuchMethodException e) + { + throw new RuntimeException(e); + } + } + + public List<AnnotatedParameter<WashingMachine>> getParameters() + { + return Collections.emptyList(); + } + + public AnnotatedType<WashingMachine> getDeclaringType() + { + return type; + } + + public boolean isStatic() + { + return false; + } + + public <T extends Annotation> T getAnnotation(Class<T> annotationType) + { + return null; + } + + public Set<Annotation> getAnnotations() + { + return Collections.emptySet(); + } + + public Type getBaseType() + { + return WashingMachine.class; + } + + public Set<Type> getTypeClosure() + { + return Arrays2.<Type>asSet(WashingMachine.class, Object.class); + } + + public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) + { + return false; + } + }; + constructors.add(constructor); + + beforeBeanDiscovery.addAnnotatedType(type); } } Modified: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtensionTest.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtensionTest.java 2010-01-27 20:25:08 UTC (rev 5646) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtensionTest.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -16,13 +16,21 @@ */ package org.jboss.weld.tests.extensions.annotatedType; +import java.lang.reflect.Constructor; +import java.lang.reflect.Method; +import java.util.Arrays; +import java.util.Set; + import javax.enterprise.inject.Any; +import javax.enterprise.inject.spi.AnnotatedConstructor; +import javax.enterprise.inject.spi.AnnotatedField; +import javax.enterprise.inject.spi.AnnotatedMethod; +import javax.enterprise.inject.spi.AnnotatedParameter; import javax.enterprise.inject.spi.Bean; +import javax.enterprise.inject.spi.InjectionPoint; import org.jboss.testharness.impl.packaging.Artifact; import org.jboss.testharness.impl.packaging.IntegrationTest; -import org.jboss.testharness.impl.packaging.Packaging; -import org.jboss.testharness.impl.packaging.PackagingType; import org.jboss.testharness.impl.packaging.jsr299.Extension; import org.jboss.weld.test.AbstractWeldTest; import org.jboss.weld.test.Utils; @@ -31,7 +39,6 @@ @Artifact @IntegrationTest -(a)Packaging(PackagingType.EAR) @Extension("javax.enterprise.inject.spi.Extension") public class AnnotatedTypeExtensionTest extends AbstractWeldTest { @@ -49,7 +56,102 @@ { Bean<WashingMachine> bean = getBean(WashingMachine.class, EcoFriendlyWashingMachineLiteral.INSTANCE); assert Utils.annotationSetMatches(bean.getQualifiers(), Any.class, EcoFriendlyWashingMachine.class); + + // Verify overriding the class structure works + Clothes.reset(); + TumbleDryer tumbleDryer = getReference(TumbleDryer.class); + Bean<TumbleDryer> tumbleDryerBean = getBean(TumbleDryer.class); + assert tumbleDryer != null; + + assert !containsConstructor(tumbleDryerBean.getInjectionPoints(), SerialNumber.class); + assert containsConstructor(tumbleDryerBean.getInjectionPoints(), Clothes.class); + assert tumbleDryer.getSerialNumber() == null; + assert tumbleDryer.getClothes() != null; + assert !Clothes.getInjectionPoint().getAnnotated().isAnnotationPresent(Original.class); + AnnotatedConstructor<?> clothesConstructor = getConstructor(tumbleDryerBean.getInjectionPoints(), Clothes.class); + assert clothesConstructor.getParameters().get(0).isAnnotationPresent(Special.class); + assert !clothesConstructor.getParameters().get(0).isAnnotationPresent(Original.class); + + assert containsField(tumbleDryerBean.getInjectionPoints(), "plug"); + assert !containsField(tumbleDryerBean.getInjectionPoints(), "coins"); + assert tumbleDryer.getPlug() != null; + assert tumbleDryer.getCoins() == null; + + assert containsMethod(tumbleDryerBean.getInjectionPoints(), "setRunningTime", RunningTime.class); + assert !containsMethod(tumbleDryerBean.getInjectionPoints(), "setHotAir", HotAir.class); + assert tumbleDryer.getRunningTime() != null; + assert tumbleDryer.getHotAir() == null; + AnnotatedMethod<?> runningTimeMethod = getMethod(tumbleDryerBean.getInjectionPoints(), "setRunningTime", RunningTime.class); + assert runningTimeMethod.getParameters().get(0).isAnnotationPresent(Special.class); + assert !runningTimeMethod.getParameters().get(0).isAnnotationPresent(Original.class); } + private static boolean containsField(Set<InjectionPoint> injectionPoints, String name) + { + for (InjectionPoint ip : injectionPoints) + { + if (ip.getAnnotated() instanceof AnnotatedField<?>) + { + AnnotatedField<?> field = (AnnotatedField<?>) ip.getAnnotated(); + if (field.getJavaMember().getName().equals(name)) + { + return true; + } + } + } + return false; + } + + private static boolean containsConstructor(Set<InjectionPoint> injectionPoints, Class<?>... parameters) + { + return getConstructor(injectionPoints, parameters) != null; + } + + private static AnnotatedConstructor<?> getConstructor(Set<InjectionPoint> injectionPoints, Class<?>... parameters) + { + for (InjectionPoint ip : injectionPoints) + { + if (ip.getAnnotated() instanceof AnnotatedParameter<?>) + { + AnnotatedParameter<?> param = (AnnotatedParameter<?>) ip.getAnnotated(); + if (param.getDeclaringCallable() instanceof AnnotatedConstructor<?>) + { + Class<?>[] parameterTypes = ((Constructor<?>) param.getDeclaringCallable().getJavaMember()).getParameterTypes(); + if (Arrays.equals(parameters, parameterTypes)) + { + return (AnnotatedConstructor<?>) param.getDeclaringCallable(); + } + } + } + } + return null; + } + + private static boolean containsMethod(Set<InjectionPoint> injectionPoints, String name, Class<?>... parameters) + { + return getMethod(injectionPoints, name, parameters) != null; + } + + private static AnnotatedMethod<?> getMethod(Set<InjectionPoint> injectionPoints, String name, Class<?>... parameters) + { + for (InjectionPoint ip : injectionPoints) + { + if (ip.getAnnotated() instanceof AnnotatedParameter<?>) + { + AnnotatedParameter<?> param = (AnnotatedParameter<?>) ip.getAnnotated(); + if (param.getDeclaringCallable() instanceof AnnotatedMethod<?>) + { + Class<?>[] parameterTypes = ((Method) param.getDeclaringCallable().getJavaMember()).getParameterTypes(); + String methodName = param.getDeclaringCallable().getJavaMember().getName(); + if (Arrays.equals(parameters, parameterTypes) && methodName.equals(name)) + { + return (AnnotatedMethod<?>) param.getDeclaringCallable(); + } + } + } + } + return null; + } + } Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Clothes.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Clothes.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Clothes.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -0,0 +1,28 @@ +package org.jboss.weld.tests.extensions.annotatedType; + +import javax.enterprise.inject.spi.InjectionPoint; +import javax.inject.Inject; + +@Special +public class Clothes +{ + + private static InjectionPoint injectionPoint; + + @Inject + public void setInjectionPoint(InjectionPoint injectionPoint) + { + Clothes.injectionPoint = injectionPoint; + } + + public static void reset() + { + injectionPoint = null; + } + + public static InjectionPoint getInjectionPoint() + { + return injectionPoint; + } + +} Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Clothes.java ___________________________________________________________________ Name: svn:eol-style + native Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Coins.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Coins.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Coins.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -0,0 +1,6 @@ +package org.jboss.weld.tests.extensions.annotatedType; + +public class Coins +{ + +} Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Coins.java ___________________________________________________________________ Name: svn:eol-style + native Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/HotAir.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/HotAir.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/HotAir.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -0,0 +1,6 @@ +package org.jboss.weld.tests.extensions.annotatedType; + +public class HotAir +{ + +} Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/HotAir.java ___________________________________________________________________ Name: svn:eol-style + native Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/InjectLiteral.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/InjectLiteral.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/InjectLiteral.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -0,0 +1,29 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat, Inc., and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jboss.weld.tests.extensions.annotatedType; + +import javax.enterprise.util.AnnotationLiteral; +import javax.inject.Inject; + +public class InjectLiteral extends AnnotationLiteral<Inject> implements Inject +{ + + public static final Inject INSTANCE = new InjectLiteral(); + + private InjectLiteral() {} + +} \ No newline at end of file Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/InjectLiteral.java ___________________________________________________________________ Name: svn:eol-style + native Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Original.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Original.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Original.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -0,0 +1,38 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2010, Red Hat, Inc., and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jboss.weld.tests.extensions.annotatedType; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Documented; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +import javax.inject.Qualifier; + +@Target( { TYPE, METHOD, PARAMETER, FIELD }) +@Retention(RUNTIME) +@Documented +@Qualifier +public @interface Original +{ + +} Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Original.java ___________________________________________________________________ Name: svn:eol-style + native Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Plug.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Plug.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Plug.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -0,0 +1,7 @@ +package org.jboss.weld.tests.extensions.annotatedType; + +@Special +public class Plug +{ + +} Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Plug.java ___________________________________________________________________ Name: svn:eol-style + native Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/RunningTime.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/RunningTime.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/RunningTime.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -0,0 +1,7 @@ +package org.jboss.weld.tests.extensions.annotatedType; + +@Special +public class RunningTime +{ + +} Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/RunningTime.java ___________________________________________________________________ Name: svn:eol-style + native Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/SerialNumber.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/SerialNumber.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/SerialNumber.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -0,0 +1,6 @@ +package org.jboss.weld.tests.extensions.annotatedType; + +public class SerialNumber +{ + +} Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/SerialNumber.java ___________________________________________________________________ Name: svn:eol-style + native Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Special.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Special.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Special.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -0,0 +1,38 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2010, Red Hat, Inc., and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jboss.weld.tests.extensions.annotatedType; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Documented; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +import javax.inject.Qualifier; + +@Target( { TYPE, METHOD, PARAMETER, FIELD }) +@Retention(RUNTIME) +@Documented +@Qualifier +public @interface Special +{ + +} Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Special.java ___________________________________________________________________ Name: svn:eol-style + native Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/SpecialLiteral.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/SpecialLiteral.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/SpecialLiteral.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -0,0 +1,28 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat, Inc., and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jboss.weld.tests.extensions.annotatedType; + +import javax.enterprise.util.AnnotationLiteral; + +public class SpecialLiteral extends AnnotationLiteral<Special> implements Special +{ + + public static final Special INSTANCE = new SpecialLiteral(); + + private SpecialLiteral() {} + +} \ No newline at end of file Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/SpecialLiteral.java ___________________________________________________________________ Name: svn:eol-style + native Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/TumbleDryer.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/TumbleDryer.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/TumbleDryer.java 2010-01-28 00:22:07 UTC (rev 5647) @@ -0,0 +1,77 @@ +package org.jboss.weld.tests.extensions.annotatedType; + +import javax.inject.Inject; + + +public class TumbleDryer +{ + + + private Plug plug; + + @Inject @Original + private Coins coins; + + private final Clothes clothers; + + private RunningTime runningTime; + + private final SerialNumber serialNumber; + + private HotAir hotAir; + + public TumbleDryer(@Original Clothes clothes) + { + this.clothers = clothes; + this.serialNumber = null; + } + + @Inject + public TumbleDryer(SerialNumber serialNumber) + { + this.serialNumber = serialNumber; + this.clothers = null; + } + + public void setRunningTime(@Original RunningTime runningTime) + { + this.runningTime = runningTime; + } + + @Inject + public void setHotAir(HotAir hotAir) + { + this.hotAir = hotAir; + } + + public Plug getPlug() + { + return plug; + } + + public Clothes getClothes() + { + return clothers; + } + + public HotAir getHotAir() + { + return hotAir; + } + + public RunningTime getRunningTime() + { + return runningTime; + } + + public SerialNumber getSerialNumber() + { + return serialNumber; + } + + public Coins getCoins() + { + return coins; + } + +} Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/TumbleDryer.java ___________________________________________________________________ Name: svn:eol-style + native