package org.testng.internal.annotations;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;
import org.testng.ITestNGMethod;
import org.testng.internal.TestNGMethod;
import org.testng.internal.Utils;
/**
* Helper methods to find @Test and @Configuration tags. They minimize
* the amount of casting we need to do.
*
* Created on Dec 20, 2005
* @author cbeust
*/
public class AnnotationHelper {
public static ITest findTest(IAnnotationFinder finder, Class cls) {
return (ITest) finder.findAnnotation(cls, ITest.class);
}
public static ITest findTest(IAnnotationFinder finder, Method m) {
return (ITest) finder.findAnnotation(m, ITest.class);
}
public static ITest findTest(IAnnotationFinder finder, Constructor ctor) {
return (ITest) finder.findAnnotation(ctor, ITest.class);
}
public static IConfiguration findConfiguration(IAnnotationFinder finder, Constructor ctor) {
IConfiguration result = (IConfiguration) finder.findAnnotation(ctor, IConfiguration.class);
if (result == null) {
IConfiguration bs = (IConfiguration) finder.findAnnotation(ctor, IBeforeSuite.class);
IConfiguration as = (IConfiguration) finder.findAnnotation(ctor, IAfterSuite.class);
IConfiguration bt = (IConfiguration) finder.findAnnotation(ctor, IBeforeTest.class);
IConfiguration at = (IConfiguration) finder.findAnnotation(ctor, IAfterTest.class);
IConfiguration bg = (IConfiguration) finder.findAnnotation(ctor, IBeforeGroups.class);
IConfiguration ag = (IConfiguration) finder.findAnnotation(ctor, IAfterGroups.class);
IConfiguration bc = (IConfiguration) finder.findAnnotation(ctor, IBeforeClass.class);
IConfiguration ac = (IConfiguration) finder.findAnnotation(ctor, IAfterClass.class);
IConfiguration bm = (IConfiguration) finder.findAnnotation(ctor, IBeforeMethod.class);
IConfiguration am = (IConfiguration) finder.findAnnotation(ctor, IAfterMethod.class);
if (bs != null || as != null || bt != null || at != null || bg != null || ag != null
|| bc != null || ac != null || bm != null || am != null)
{
result = createConfiguration(bs, as, bt, at, bg, ag, bc, ac, bm, am);
}
}
return result;
}
public static IConfiguration findConfiguration(IAnnotationFinder finder, Method m) {
IConfiguration result = (IConfiguration) finder.findAnnotation(m, IConfiguration.class);
if (result == null) {
IConfiguration bs = (IConfiguration) finder.findAnnotation(m, IBeforeSuite.class);
IConfiguration as = (IConfiguration) finder.findAnnotation(m, IAfterSuite.class);
IConfiguration bt = (IConfiguration) finder.findAnnotation(m, IBeforeTest.class);
IConfiguration at = (IConfiguration) finder.findAnnotation(m, IAfterTest.class);
IConfiguration bg = (IConfiguration) finder.findAnnotation(m, IBeforeGroups.class);
IConfiguration ag = (IConfiguration) finder.findAnnotation(m, IAfterGroups.class);
IConfiguration bc = (IConfiguration) finder.findAnnotation(m, IBeforeClass.class);
IConfiguration ac = (IConfiguration) finder.findAnnotation(m, IAfterClass.class);
IConfiguration bm = (IConfiguration) finder.findAnnotation(m, IBeforeMethod.class);
IConfiguration am = (IConfiguration) finder.findAnnotation(m, IAfterMethod.class);
if (bs != null || as != null || bt != null || at != null || bg != null || ag != null
|| bc != null || ac != null || bm != null || am != null)
{
result = createConfiguration(bs, as, bt, at, bg, ag, bc, ac, bm, am);
}
}
return result;
}
private static IConfiguration createConfiguration(IConfiguration bs, IConfiguration as,
IConfiguration bt, IConfiguration at, IConfiguration bg, IConfiguration ag,
IConfiguration bc, IConfiguration ac, IConfiguration bm, IConfiguration am)
{
ConfigurationAnnotation result = new ConfigurationAnnotation();
if (bs != null) {
result.setBeforeSuite(true);
finishInitialize(result, bs);
}
if (as != null) {
result.setAfterSuite(true);
finishInitialize(result, as);
}
if (bt != null) {
result.setBeforeTest(true);
finishInitialize(result, bt);
}
if (at != null) {
result.setAfterTest(true);
finishInitialize(result, at);
}
if (bg != null) {
result.setBeforeGroups(bg.getBeforeGroups());
finishInitialize(result, bg);
}
if (ag != null) {
result.setAfterGroups(ag.getAfterGroups());
finishInitialize(result, ag);
}
if (bc != null) {
result.setBeforeTestClass(true);
finishInitialize(result, bc);
}
if (ac != null) {
result.setAfterTestClass(true);
finishInitialize(result, ac);
}
if (bm != null) {
result.setBeforeTestMethod(true);
finishInitialize(result, bm);
}
if (am != null) {
result.setAfterTestMethod(true);
finishInitialize(result, am);
}
return result;
}
@SuppressWarnings({"deprecation"})
private static void finishInitialize(ConfigurationAnnotation result, IConfiguration bs) {
result.setFakeConfiguration(true);
result.setAlwaysRun(bs.getAlwaysRun());
result.setDependsOnGroups(bs.getDependsOnGroups());
result.setDependsOnMethods(bs.getDependsOnGroups());
result.setDescription(bs.getDescription());
result.setEnabled(bs.getEnabled());
result.setGroups(bs.getGroups());
result.setInheritGroups(bs.getInheritGroups());
result.setParameters(bs.getParameters());
}
private static Class[] ALL_ANNOTATIONS = new Class[] {
ITest.class, IConfiguration.class,
IBeforeClass.class, IAfterClass.class,
IBeforeMethod.class, IAfterMethod.class,
IDataProvider.class, IExpectedExceptions.class,
IFactory.class, IParameters.class,
IBeforeSuite.class, IAfterSuite.class,
IBeforeTest.class, IAfterTest.class,
IBeforeGroups.class, IAfterGroups.class,
};
public static Class[] CONFIGURATION_CLASSES = new Class[] {
IConfiguration.class,
IBeforeSuite.class, IAfterSuite.class,
IBeforeTest.class, IAfterTest.class,
IBeforeGroups.class, IAfterGroups.class,
IBeforeClass.class, IAfterClass.class,
IBeforeMethod.class, IAfterMethod.class
};
public static Class[] getAllAnnotations() {
return ALL_ANNOTATIONS;
};
/**
* Delegation method for creating the list of <CODE>ITestMethod</CODE>s to be
* analysed.
*/
public static ITestNGMethod[] findMethodsWithAnnotation(Class rootClass, Class annotationClass,
IAnnotationFinder annotationFinder)
{
// Keep a map of the methods we saw so that we ignore a method in a superclass if it's
// already been seen in a child class
Map<String, ITestNGMethod> vResult = new HashMap<String, ITestNGMethod>();
try {
vResult = new HashMap<String, ITestNGMethod>();
// Class[] classes = rootClass.getTestClasses();
Class cls = rootClass;
//
// If the annotation is on the class or superclass, it applies to all public methods
// except methods marked with @Configuration
//
//
// Otherwise walk through all the methods and keep those
// that have the annotation
//
// for (Class cls : classes) {
while (null != cls) {
boolean hasClassAnnotation = isAnnotationPresent(annotationFinder, cls, annotationClass);
Method[] methods = cls.getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
Method m = methods[i];
boolean hasMethodAnnotation = isAnnotationPresent(annotationFinder, m, annotationClass);
boolean hasTestNGAnnotation =
isAnnotationPresent(annotationFinder, m, IFactory.class) ||
isAnnotationPresent(annotationFinder, m, ITest.class) ||
isAnnotationPresent(annotationFinder, m, CONFIGURATION_CLASSES);
boolean isPublic = Modifier.isPublic(m.getModifiers());
if ((isPublic && hasClassAnnotation && (! hasTestNGAnnotation)) || hasMethodAnnotation) {
// Small hack to allow users to specify @Configuration classes even though
// a class-level @Test annotation is present. In this case, don't count
// that method as a @Test
if (isAnnotationPresent(annotationFinder, m, IConfiguration.class) &&
isAnnotationPresent(annotationFinder, cls, ITest.class))
{
Utils.log("", 3, "Method " + m + " has a local @Configuration and a class-level @Test." +
"This method will only be kept as a @Configuration.");
continue;
}
String key = createMethodKey(m);
if (null == vResult.get(key)) {
ITestNGMethod tm = new TestNGMethod(/* m.getDeclaringClass(), */ m, annotationFinder);
vResult.put(key,tm);
}
}
} // for
// Now explore the superclass
cls = cls.getSuperclass();
} // while
}
catch (SecurityException e) {
e.printStackTrace();
}
ITestNGMethod[] result = (ITestNGMethod[]) vResult.values().toArray(new ITestNGMethod[vResult.size()]);
// for (Method m : result) {
// ppp(" METHOD FOUND: " + m);
// }
return result;
}
private static boolean isAnnotationPresent(IAnnotationFinder annotationFinder,
Method m, Class[] annotationClasses)
{
for (Class a : annotationClasses) {
if (annotationFinder.findAnnotation(m, a) != null) {
return true;
}
}
return false;
}
private static boolean isAnnotationPresent(IAnnotationFinder annotationFinder, Method m, Class annotationClass) {
return annotationFinder.findAnnotation(m, annotationClass) != null;
}
private static boolean isAnnotationPresent(IAnnotationFinder annotationFinder, Class cls, Class annotationClass) {
return annotationFinder.findAnnotation(cls, annotationClass) != null;
}
/**
* @return A hashcode representing the name of this method and its parameters,
* but without its class
*/
private static String createMethodKey(Method m) {
StringBuffer result = new StringBuffer(m.getName());
for (Class paramClass : m.getParameterTypes()) {
result.append(" ").append(paramClass.toString());
}
return result.toString();
}
}