Author: shane.bryzak(a)jboss.com Date: 2009-01-09 02:25:50 -0500 (Fri, 09 Jan 2009) New Revision: 841 Added: tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/TckUtils.java tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/util/Reflections.java Modified: tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/Beans.java tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/Contexts.java tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/Managers.java tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/util/DeploymentProperties.java Log: refactor Modified: tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/Beans.java =================================================================== --- tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/Beans.java 2009-01-09 06:41:20 UTC (rev 840) +++ tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/Beans.java 2009-01-09 07:25:50 UTC (rev 841) @@ -5,7 +5,7 @@ * * @author Shane Bryzak */ -public abstract class Beans extends Configurable +public interface Beans { } Modified: tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/Contexts.java =================================================================== --- tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/Contexts.java 2009-01-09 06:41:20 UTC (rev 840) +++ tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/Contexts.java 2009-01-09 07:25:50 UTC (rev 841) @@ -1,10 +1,32 @@ package org.jboss.webbeans.tck.api; +import javax.webbeans.manager.Context; + /** + * Context related operations * * @author Shane Bryzak */ -public abstract class Contexts extends Configurable +public interface Contexts { - + /** + * Sets the specified context as active + * + * @param context The context to set active + */ + void setActive(Context context); + + /** + * Sets the specified context as inactive + * + * @param context The context to set inactive + */ + void setInactive(Context context); + + /** + * Creates a new request context + * + * @return The new request context + */ + Context createRequestContext(); } Modified: tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/Managers.java =================================================================== --- tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/Managers.java 2009-01-09 06:41:20 UTC (rev 840) +++ tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/Managers.java 2009-01-09 07:25:50 UTC (rev 841) @@ -6,35 +6,25 @@ import javax.webbeans.manager.Manager; /** - * This class provides operations relating to a Web Beans Manager. + * This interface provides operations relating to a Web Beans Manager. * - * The TCK porting package must provide an implementation of this abstract class which is + * The TCK porting package must provide an implementation of this interface which is * suitable for the target Web Beans implementation. * * @author Shane Bryzak */ -public abstract class Managers extends Configurable -{ +public interface Managers +{ /** - * Returns the concrete implementation of Managers * - * @return - */ - public static Managers instance() - { - return (Managers) getInstance(Managers.class); - } - - /** - * * @param enabledDeploymentTypes */ - public abstract void setEnabledDeploymentTypes(List<Class<? extends Annotation>> enabledDeploymentTypes); + void setEnabledDeploymentTypes(List<Class<? extends Annotation>> enabledDeploymentTypes); /** * Creates a new Manager instance * * @return The new Manager */ - public abstract Manager createManager(); + Manager createManager(); } Added: tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/TckUtils.java =================================================================== --- tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/TckUtils.java (rev 0) +++ tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/TckUtils.java 2009-01-09 07:25:50 UTC (rev 841) @@ -0,0 +1,62 @@ +package org.jboss.webbeans.tck.api; + +import java.lang.reflect.Constructor; + +import org.jboss.webbeans.tck.api.util.DeploymentProperties; +import org.jboss.webbeans.tck.api.util.Reflections; + +/** + * + * @author Shane Bryzak + * + */ +public class TckUtils +{ + private static DeploymentProperties deploymentProperties = new DeploymentProperties(); + + public static Managers getManagers() + { + Managers managers = null; + + for (Class<? extends Managers> cls : deploymentProperties.getClasses(Managers.class.getName(), Managers.class)) + { + Constructor<? extends Managers> constructor = Reflections.getConstructor(cls); + if (constructor != null) + { + try + { + managers = constructor.newInstance(); + } + catch (Exception ex) + { + // Do something with the exception (log it?) + } + } + } + + return managers; + } + + public static Contexts getContexts() + { + Contexts contexts = null; + + for (Class<? extends Contexts> cls : deploymentProperties.getClasses(Contexts.class.getName(), Contexts.class)) + { + Constructor<? extends Contexts> constructor = Reflections.getConstructor(cls); + if (constructor != null) + { + try + { + contexts = constructor.newInstance(); + } + catch (Exception ex) + { + // Do something with the exception (log it?) + } + } + } + + return contexts; + } +} Modified: tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/util/DeploymentProperties.java =================================================================== --- tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/util/DeploymentProperties.java 2009-01-09 06:41:20 UTC (rev 840) +++ tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/util/DeploymentProperties.java 2009-01-09 07:25:50 UTC (rev 841) @@ -40,9 +40,6 @@ * First, System properties are tried, followed by the specified resource * bundle (first in classpath only). * - * Colon (:) deliminated lists are split out. (gotta love Petes choice of - * ASCII art for that one ;-) - * * @param key The key to search for * @return A list of possible values. An empty list is returned if there are * no matches. @@ -131,10 +128,10 @@ * @return A set of classes specified */ @SuppressWarnings("unchecked") - public static <T> Set<Class<? extends T>> getClasses(DeploymentProperties deploymentProperties, SimpleResourceLoader resourceLoader, String propertyName, Class<T> expectedType) + public <T> Set<Class<? extends T>> getClasses(String propertyName, Class<T> expectedType) { Set<Class<? extends T>> classes = new HashSet<Class<? extends T>>(); - for (String className : deploymentProperties.getPropertyValues(propertyName)) + for (String className : getPropertyValues(propertyName)) { try { Added: tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/util/Reflections.java =================================================================== --- tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/util/Reflections.java (rev 0) +++ tck/trunk/api/src/main/java/org/jboss/webbeans/tck/api/util/Reflections.java 2009-01-09 07:25:50 UTC (rev 841) @@ -0,0 +1,629 @@ +package org.jboss.webbeans.tck.api.util; + +import java.beans.Introspector; +import java.io.Serializable; +import java.lang.annotation.Annotation; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Member; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import javax.webbeans.BindingType; +import javax.webbeans.ExecutionException; + +/** + * Utility class for static reflection-type operations + * + * @author Pete Muir + * + */ +public class Reflections +{ + + /** + * Gets the property name from a getter method + * + * @param method The getter method + * @return The name of the property. Returns null if method wasn't JavaBean + * getter-styled + */ + public static String getPropertyName(Method method) + { + String methodName = method.getName(); + if (methodName.matches("^(get).*") && method.getParameterTypes().length == 0) + { + return Introspector.decapitalize(methodName.substring(3)); + } + else if (methodName.matches("^(is).*") && method.getParameterTypes().length == 0) + { + return Introspector.decapitalize(methodName.substring(2)); + } + else + { + return null; + } + + } + + /** + * Checks if class is final + * + * @param clazz The class to check + * @return True if final, false otherwise + */ + public static boolean isFinal(Class<?> clazz) + { + return Modifier.isFinal(clazz.getModifiers()); + } + + /** + * Checks if member is final + * + * @param member The member to check + * @return True if final, false otherwise + */ + public static boolean isFinal(Member member) + { + return Modifier.isFinal(member.getModifiers()); + } + + /** + * Checks if type or member is final + * + * @param type Type or member + * @return True if final, false otherwise + */ + public static boolean isTypeOrAnyMethodFinal(Class<?> type) + { + if (isFinal(type)) + { + return true; + } + for (Method method : type.getDeclaredMethods()) + { + if (isFinal(method)) + { + return true; + } + } + return false; + } + + /** + * Checks if type is primitive + * + * @param type Type to check + * @return True if primitive, false otherwise + */ + public static boolean isPrimitive(Class<?> type) + { + return type.isPrimitive(); + } + + /** + * Checks if type is static + * + * @param type Type to check + * @return True if static, false otherwise + */ + public static boolean isStatic(Class<?> type) + { + return Modifier.isStatic(type.getModifiers()); + } + + /** + * Checks if member is static + * + * @param member Member to check + * @return True if static, false otherwise + */ + public static boolean isStatic(Member member) + { + return Modifier.isStatic(member.getModifiers()); + } + + public static boolean isTransient(Member member) + { + return Modifier.isTransient(member.getModifiers()); + } + + /** + * Checks if clazz is abstract + * + * @param clazz Class to check + * @return True if abstract, false otherwise + */ + public static boolean isAbstract(Class<?> clazz) + { + return Modifier.isAbstract(clazz.getModifiers()); + } + + /** + * Checks if class is a static inner one + * + * @param clazz Class to check + * @return True if static, false otherwise + */ + public static boolean isStaticInnerClass(Class<?> clazz) + { + return clazz.isMemberClass() && isStatic(clazz); + } + + /** + * Checks if class is a non-static inner one + * + * @param clazz Class to Check + * @return True if static, false otherwise + */ + public static boolean isNonStaticInnerClass(Class<?> clazz) + { + return clazz.isMemberClass() && !isStatic(clazz); + } + + /** + * Gets a constructor with matching parameter types + * + * @param <T> The type + * @param clazz The class + * @param parameterTypes The parameter types + * @return The matching constructor. Null is returned if none is found + */ + public static <T> Constructor<T> getConstructor(Class<T> clazz, Class<?>... parameterTypes) + { + try + { + return clazz.getConstructor(parameterTypes); + } + catch (NoSuchMethodException e) + { + return null; + } + catch (Exception e) + { + throw new RuntimeException("Error accessing constructor (with parameters " + parameterTypes + ") of " + clazz, e); + } + } + + /** + * Gets all methods with a given annotation + * + * @param clazz The class the examine + * @param annotationType The annotation type to search for + * @return A list of matching methods. An empty list is returned if no + * matches are found + */ + public static List<Method> getMethods(Class<?> clazz, Class<? extends Annotation> annotationType) + { + List<Method> methods = new ArrayList<Method>(); + for (Method method : clazz.getMethods()) + { + if (method.isAnnotationPresent(annotationType)) + { + methods.add(method); + } + } + return methods; + } + + /** + * Gets all constructors with a given annotation + * + * @param <T> The type of the class + * @param clazz The class + * @param annotationType The annotation type + * @return A list of matching constructors. An empty list is returned if no + * matches are found + */ + @SuppressWarnings("unchecked") + public static <T> List<Constructor<T>> getAnnotatedConstructors(Class<? extends T> clazz, Class<? extends Annotation> annotationType) + { + List<Constructor<T>> constructors = new ArrayList<Constructor<T>>(); + for (Constructor<?> constructor : clazz.getConstructors()) + { + if (constructor.isAnnotationPresent(annotationType)) + { + constructors.add((Constructor<T>) constructor); + } + } + return constructors; + } + + /** + * Gets constructors with a given annotated parameter + * + * @param <T> The type + * @param clazz The class + * @param parameterAnnotationType The parameter annotation type + * @return A list of matching constructors. An empty list is returned if no + * matches are found + */ + @SuppressWarnings("unchecked") + public static <T> List<Constructor<T>> getConstructorsForAnnotatedParameter(Class<? extends T> clazz, Class<? extends Annotation> parameterAnnotationType) + { + List<Constructor<T>> constructors = new ArrayList<Constructor<T>>(); + for (Constructor<?> constructor : clazz.getConstructors()) + { + for (Annotation[] annotations : constructor.getParameterAnnotations()) + { + for (Annotation annotation : annotations) + { + if (annotation.annotationType().equals(parameterAnnotationType)) + { + constructors.add((Constructor<T>) constructor); + } + } + } + } + return constructors; + } + + /** + * Gets constructors with a given meta-annotated parameter + * + * @param <T> The type + * @param clazz The class + * @param metaAnnotationType The parameter meta-annotation type + * @return A list of matching constructors. An empty list is returned if no + * matches are found + */ + @SuppressWarnings("unchecked") + public static <T> List<Constructor<T>> getConstructorsForMetaAnnotatedParameter(Class<? extends T> clazz, Class<? extends Annotation> metaAnnotationType) + { + List<Constructor<T>> constructors = new ArrayList<Constructor<T>>(); + for (Constructor<?> constructor : clazz.getConstructors()) + { + for (Annotation[] annotations : constructor.getParameterAnnotations()) + { + for (Annotation annotation : annotations) + { + if (annotation.annotationType().isAnnotationPresent(metaAnnotationType)) + { + constructors.add((Constructor<T>) constructor); + } + } + } + } + return constructors; + } + + /** + * Checks if all annotations types are in a given set of annotations + * + * @param annotations The annotation set + * @param annotationTypes The annotation types to match + * @return True if match, false otherwise + */ + public static boolean annotationTypeSetMatches(Set<Class<? extends Annotation>> annotations, Class<? extends Annotation>... annotationTypes) + { + List<Class<? extends Annotation>> annotationTypeList = new ArrayList<Class<? extends Annotation>>(); + annotationTypeList.addAll(Arrays.asList(annotationTypes)); + for (Class<? extends Annotation> annotation : annotations) + { + if (annotationTypeList.contains(annotation)) + { + annotationTypeList.remove(annotation); + } + else + { + return false; + } + } + return annotationTypeList.size() == 0; + } + + /** + * Checks if all annotations are in a given set of annotations + * + * @param annotations The annotation set + * @param annotationTypes The annotations to match + * @return True if match, false otherwise + */ + public static boolean annotationSetMatches(Set<Annotation> annotations, Class<? extends Annotation>... annotationTypes) + { + List<Class<? extends Annotation>> annotationTypeList = new ArrayList<Class<? extends Annotation>>(); + annotationTypeList.addAll(Arrays.asList(annotationTypes)); + for (Annotation annotation : annotations) + { + if (annotationTypeList.contains(annotation.annotationType())) + { + annotationTypeList.remove(annotation.annotationType()); + } + else + { + return false; + } + } + return annotationTypeList.size() == 0; + } + + /** + * Gets the actual type arguments of a class + * + * @param clazz The class to examine + * @return The type arguments + */ + public static Type[] getActualTypeArguments(Class<?> clazz) + { + if (clazz.getGenericSuperclass() instanceof ParameterizedType) + { + return ((ParameterizedType) clazz.getGenericSuperclass()).getActualTypeArguments(); + } + else + { + return new Type[0]; + } + } + + /** + * Checks if raw type is array type + * + * @param rawType The raw type to check + * @return True if array, false otherwise + */ + public static boolean isArrayType(Class<?> rawType) + { + return rawType.isArray(); + } + + /** + * Checks if type is parameterized type + * + * @param type The type to check + * @return True if parameterized, false otherwise + */ + public static boolean isParameterizedType(Class<?> type) + { + return type.getTypeParameters().length > 0; + } + + /** + * Invokes a method and wraps exceptions + * + * @param method The method to invoke + * @param instance The instance to invoke on + * @param parameters The parameters + * @return The return value + */ + public static Object invokeAndWrap(Method method, Object instance, Object... parameters) + { + try + { + return method.invoke(instance, parameters); + } + catch (IllegalArgumentException e) + { + throw new ExecutionException("Error invoking method " + method.getName() + " on " + method.getDeclaringClass(), e); + } + catch (IllegalAccessException e) + { + throw new ExecutionException("Error invoking method " + method.getName() + " on " + method.getDeclaringClass(), e); + } + catch (InvocationTargetException e) + { + throw new ExecutionException("Error invoking method " + method.getName() + " on " + method.getDeclaringClass(), e); + } + } + + /** + * Invokes a method and wraps exceptions + * + * @param methodName The method name to find on the instance and invoke + * @param parameterTypes The method name to find on the instance and invoke + * @param instance The instance to invoke on + * @param parameterValues The parameters values + * @return The return value + */ + public static Object invokeAndWrap(String methodName, Class<?>[] parameterTypes, Object instance, Object[] parameterValues) + { + try + { + return instance.getClass().getMethod(methodName, parameterTypes).invoke(instance, parameterValues); + } + catch (IllegalArgumentException e) + { + throw new ExecutionException("Error invoking method " + methodName + " on " + instance.getClass(), e); + } + catch (IllegalAccessException e) + { + throw new ExecutionException("Error invoking method " + methodName + " on " + instance.getClass(), e); + } + catch (InvocationTargetException e) + { + throw new ExecutionException("Error invoking method " + methodName + " on " + instance.getClass(), e); + } + catch (SecurityException e) + { + throw new ExecutionException("Error invoking method " + methodName + " on " + instance.getClass(), e); + } + catch (NoSuchMethodException e) + { + throw new ExecutionException("Error invoking method " + methodName + " on " + instance.getClass(), e); + } + } + + /** + * Sets value of a field and wraps exceptions + * + * @param field The field to set on + * @param target The instance to set on + * @param value The value to set + */ + public static void setAndWrap(Field field, Object target, Object value) + { + try + { + field.set(target, value); + } + catch (IllegalArgumentException e) + { + throw new ExecutionException("Error setting field " + field.getName() + " on " + field.getDeclaringClass(), e); + } + catch (IllegalAccessException e) + { + throw new ExecutionException("Error setting field " + field.getName() + " on " + field.getDeclaringClass(), e); + } + } + + /** + * Sets value of a field and wraps exceptions + * + * @param field The field to set on + * @param target The instance to set on + * @param value The value to set + */ + public static void setAndWrap(String fieldName, Object target, Object value) + { + try + { + target.getClass().getField(fieldName).set(target, value); + } + catch (IllegalArgumentException e) + { + throw new ExecutionException("Error setting field " + fieldName + " on " + target.getClass(), e); + } + catch (IllegalAccessException e) + { + throw new ExecutionException("Error setting field " + fieldName + " on " + target.getClass(), e); + } + catch (SecurityException e) + { + throw new ExecutionException("Error setting field " + fieldName + " on " + target.getClass(), e); + } + catch (NoSuchFieldException e) + { + throw new ExecutionException("Error setting field " + fieldName + " on " + target.getClass(), e); + } + } + + /** + * Gets value of a field and wraps exceptions + * + * @param field The field to set on + * @param target The instance to set on + * @return The value to set + */ + public static Object getAndWrap(Field field, Object target) + { + try + { + return field.get(target); + } + catch (IllegalArgumentException e) + { + throw new ExecutionException("Error getting field " + field.getName() + " on " + field.getDeclaringClass(), e); + } + catch (IllegalAccessException e) + { + throw new ExecutionException("Error getting field " + field.getName() + " on " + field.getDeclaringClass(), e); + } + } + + /** + * Looks up a method in the type hierarchy of an instance + * + * @param method The method to look for + * @param instance The instance to start from + * @return The method found, or an NoSuchMethodException if it is not found + */ + public static Method lookupMethod(Method method, Object instance) + { + for (Class<? extends Object> clazz = instance.getClass(); clazz != null; clazz = clazz.getSuperclass()) + { + try + { + Method targetMethod = clazz.getDeclaredMethod(method.getName(), method.getParameterTypes()); + if (!targetMethod.isAccessible()) + { + targetMethod.setAccessible(true); + } + return targetMethod; + } + catch (NoSuchMethodException nsme) + { + // Expected, nothing to see here. + } + } + throw new IllegalArgumentException("Method " + method.getName() + " not implemented by instance"); + } + + /** + * Indicates if an instance is a Javassist proxy + * + * @param instance The instance to examine + * @return True if proxy, false otherwise + */ + public static boolean isProxy(Object instance) + { + return instance.getClass().getName().indexOf("_$$_javassist_") > 0; + } + + /** + * Gets the type hierarchy for a class + * + * A recursive function that adds the class to the set of type and then calls + * itself with the suprerclass as paramater until the top of the hierarchy is + * reached. For each steps, adds all interfaces of the class to the set. + * Since the data structure is a set, duplications are eliminated + * + * @param clazz The class to examine + * @return The set of classes and interfaces in the hierarchy + * @see #getTypeHierachy(Class, Set) + */ + public static Set<Class<?>> getTypeHierachy(Class<?> clazz) + { + Set<Class<?>> classes = new HashSet<Class<?>>(); + getTypeHierachy(clazz, classes); + return classes; + } + + /** + * Gets the flattened type hierarchy for a class, including all super classes + * and the entire interface type hierarchy + * + * @param clazz the class to examine + * @param classes the set of types + */ + public static void getTypeHierachy(Class<?> clazz, Set<? super Class<?>> classes) + { + if (clazz != null) + { + classes.add(clazz); + getTypeHierachy(clazz.getSuperclass(), classes); + for (Class<?> c : clazz.getInterfaces()) + { + getTypeHierachy(c, classes); + } + } + } + + /** + * Checks the bindingType to make sure the annotation was declared properly + * as a binding type (annotated with @BindingType). + * + * @param bindingType The binding type to check + * @return true only if the annotation is really a binding type + */ + public static boolean isBindingType(Annotation bindingType) + { + boolean isBindingAnnotation = false; + if (bindingType.annotationType().isAnnotationPresent(BindingType.class)) + { + isBindingAnnotation = true; + } + return isBindingAnnotation; + } + + public static boolean isSerializable(Class<?> clazz) + { + return getTypeHierachy(clazz).contains(Serializable.class); + } +} \ No newline at end of file