package org.testng.internal.annotations;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import org.testng.TestNGException;
import org.testng.annotations.AfterClass;
import org.testng.annotations.AfterGroups;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.AfterSuite;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeGroups;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.BeforeSuite;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Configuration;
import org.testng.annotations.DataProvider;
import org.testng.annotations.ExpectedExceptions;
import org.testng.annotations.Factory;
import org.testng.annotations.Parameters;
import org.testng.annotations.Test;
/**
* This class creates implementations of IAnnotations based on the JDK5
* annotation that was found on the Java element.
*
* Created on Dec 20, 2005
* @author <a href="mailto:cedric@beust.com">Cedric Beust</a>
*/
public class JDK15TagFactory {
public IAnnotation createTag(Class cls, Annotation a,
Class annotationClass,
IAnnotationTransformer transformer)
{
IAnnotation result = null;
if (a != null) {
if (annotationClass == IConfiguration.class) {
result = createConfigurationTag(cls, a);
}
else if (annotationClass == IDataProvider.class) {
result = createDataProviderTag(a);
}
else if (annotationClass == IExpectedExceptions.class) {
result = createExpectedExceptionsTag(a);
}
else if (annotationClass == IFactory.class) {
result = createFactoryTag(a);
}
else if (annotationClass == IParameters.class) {
result = createParametersTag(a);
}
else if (annotationClass == ITest.class) {
result = createTestTag(cls, a, transformer);
}
else if (annotationClass == IBeforeSuite.class || annotationClass == IAfterSuite.class ||
annotationClass == IBeforeTest.class || annotationClass == IAfterTest.class ||
annotationClass == IBeforeGroups.class || annotationClass == IAfterGroups.class ||
annotationClass == IBeforeClass.class || annotationClass == IAfterClass.class ||
annotationClass == IBeforeMethod.class || annotationClass == IAfterMethod.class)
{
result = maybeCreateNewConfigurationTag(cls, a, annotationClass);
}
else {
throw new TestNGException("Unknown annotation requested:" + annotationClass);
}
}
return result;
}
private IAnnotation maybeCreateNewConfigurationTag(Class cls, Annotation a,
Class annotationClass)
{
IAnnotation result = null;
if (annotationClass == IBeforeSuite.class) {
BeforeSuite bs = (BeforeSuite) a;
result = createConfigurationTag(cls, a,
true, false,
false, false,
new String[0], new String[0],
false, false,
false, false,
bs.alwaysRun(),
bs.dependsOnGroups(), bs.dependsOnMethods(),
bs.description(), bs.enabled(), bs.groups(),
bs.inheritGroups(), null);
}
else if (annotationClass == IAfterSuite.class) {
AfterSuite bs = (AfterSuite) a;
result = createConfigurationTag(cls, a,
false, true,
false, false,
new String[0], new String[0],
false, false,
false, false,
bs.alwaysRun(),
bs.dependsOnGroups(), bs.dependsOnMethods(),
bs.description(), bs.enabled(), bs.groups(),
bs.inheritGroups(), null);
}
else if (annotationClass == IBeforeTest.class) {
BeforeTest bs = (BeforeTest) a;
result = createConfigurationTag(cls, a,
false, false,
true, false,
new String[0], new String[0],
false, false,
false, false,
bs.alwaysRun(),
bs.dependsOnGroups(), bs.dependsOnMethods(),
bs.description(), bs.enabled(), bs.groups(),
bs.inheritGroups(), null);
}
else if (annotationClass == IAfterTest.class) {
AfterTest bs = (AfterTest) a;
result = createConfigurationTag(cls, a,
false, false,
false, true,
new String[0], new String[0],
false, false,
false, false,
bs.alwaysRun(),
bs.dependsOnGroups(), bs.dependsOnMethods(),
bs.description(), bs.enabled(), bs.groups(),
bs.inheritGroups(), null);
}
else if (annotationClass == IBeforeGroups.class) {
BeforeGroups bs = (BeforeGroups) a;
final String[] groups= bs.value().length > 0 ? bs.value() : bs.groups();
result = createConfigurationTag(cls, a,
false, false,
false, false,
groups, new String[0],
false, false,
false, false,
bs.alwaysRun(),
bs.dependsOnGroups(), bs.dependsOnMethods(),
bs.description(), bs.enabled(), bs.groups(),
bs.inheritGroups(), null);
}
else if (annotationClass == IAfterGroups.class) {
AfterGroups bs = (AfterGroups) a;
final String[] groups= bs.value().length > 0 ? bs.value() : bs.groups();
result = createConfigurationTag(cls, a,
false, false,
false, false,
new String[0], groups,
false, false,
false, false,
bs.alwaysRun(),
bs.dependsOnGroups(), bs.dependsOnMethods(),
bs.description(), bs.enabled(), bs.groups(),
bs.inheritGroups(), null);
}
else if (annotationClass == IBeforeClass.class) {
BeforeClass bs = (BeforeClass) a;
result = createConfigurationTag(cls, a,
false, false,
false, false,
new String[0], new String[0],
true, false,
false, false,
bs.alwaysRun(),
bs.dependsOnGroups(), bs.dependsOnMethods(),
bs.description(), bs.enabled(), bs.groups(),
bs.inheritGroups(), null);
}
else if (annotationClass == IAfterClass.class) {
AfterClass bs = (AfterClass) a;
result = createConfigurationTag(cls, a,
false, false,
false, false,
new String[0], new String[0],
false, true,
false, false,
bs.alwaysRun(),
bs.dependsOnGroups(), bs.dependsOnMethods(),
bs.description(), bs.enabled(), bs.groups(),
bs.inheritGroups(), null);
}
else if (annotationClass == IBeforeMethod.class) {
BeforeMethod bs = (BeforeMethod) a;
result = createConfigurationTag(cls, a,
false, false,
false, false,
new String[0], new String[0],
false, false,
true, false,
bs.alwaysRun(),
bs.dependsOnGroups(), bs.dependsOnMethods(),
bs.description(), bs.enabled(), bs.groups(),
bs.inheritGroups(), null);
}
else if (annotationClass == IAfterMethod.class) {
AfterMethod bs = (AfterMethod) a;
result = createConfigurationTag(cls, a,
false, false,
false, false,
new String[0], new String[0],
false, false,
false, true,
bs.alwaysRun(),
bs.dependsOnGroups(), bs.dependsOnMethods(),
bs.description(), bs.enabled(), bs.groups(),
bs.inheritGroups(), null);
}
return result;
}
@SuppressWarnings({"deprecation"})
private IAnnotation createConfigurationTag(Class cls, Annotation a) {
ConfigurationAnnotation result = new ConfigurationAnnotation();
Configuration c = (Configuration) a;
result.setBeforeTestClass(c.beforeTestClass());
result.setAfterTestClass(c.afterTestClass());
result.setBeforeTestMethod(c.beforeTestMethod());
result.setAfterTestMethod(c.afterTestMethod());
result.setBeforeTest(c.beforeTest());
result.setAfterTest(c.afterTest());
result.setBeforeSuite(c.beforeSuite());
result.setAfterSuite(c.afterSuite());
result.setBeforeGroups(c.beforeGroups());
result.setAfterGroups(c.afterGroups());
result.setParameters(c.parameters());
result.setEnabled(c.enabled());
result.setGroups(join(c.groups(), findInheritedStringArray(cls, Test.class, "groups")));
result.setDependsOnGroups(c.dependsOnGroups());
result.setDependsOnMethods(c.dependsOnMethods());
result.setAlwaysRun(c.alwaysRun());
result.setInheritGroups(c.inheritGroups());
result.setDescription(c.description());
return result;
}
private IAnnotation createConfigurationTag(Class cls, Annotation a,
boolean beforeSuite, boolean afterSuite,
boolean beforeTest, boolean afterTest,
String[] beforeGroups, String[] afterGroups,
boolean beforeClass, boolean afterClass,
boolean beforeMethod, boolean afterMethod,
boolean alwaysRun,
String[] dependsOnGroups, String[] dependsOnMethods,
String description, boolean enabled, String[] groups,
boolean inheritGroups, String[] parameters)
{
ConfigurationAnnotation result = new ConfigurationAnnotation();
result.setFakeConfiguration(true);
result.setBeforeSuite(beforeSuite);
result.setAfterSuite(afterSuite);
result.setBeforeTestClass(beforeTest);
result.setAfterTestClass(afterTest);
result.setBeforeTestClass(beforeClass);
result.setAfterTestClass(afterClass);
result.setBeforeGroups(beforeGroups);
result.setAfterGroups(afterGroups);
result.setBeforeTestMethod(beforeMethod);
result.setAfterTestMethod(afterMethod);
result.setAlwaysRun(alwaysRun);
result.setDependsOnGroups(dependsOnGroups);
result.setDependsOnMethods(dependsOnMethods);
result.setDescription(description);
result.setEnabled(enabled);
result.setGroups(groups);
result.setInheritGroups(inheritGroups);
result.setParameters(parameters);
return result;
}
private IAnnotation createDataProviderTag(Annotation a) {
DataProviderAnnotation result = new DataProviderAnnotation();
DataProvider c = (DataProvider) a;
result.setName(c.name());
return result;
}
@SuppressWarnings({"deprecation"})
private IAnnotation createExpectedExceptionsTag(Annotation a) {
ExpectedExceptionsAnnotation result = new ExpectedExceptionsAnnotation ();
ExpectedExceptions c = (ExpectedExceptions ) a;
result.setValue(c.value());
return result;
}
@SuppressWarnings({"deprecation"})
private IAnnotation createFactoryTag(Annotation a) {
FactoryAnnotation result = new FactoryAnnotation();
Factory c = (Factory) a;
result.setParameters(c.parameters());
return result;
}
private IAnnotation createParametersTag(Annotation a) {
ParametersAnnotation result = new ParametersAnnotation();
Parameters c = (Parameters) a;
result.setValue(c.value());
return result;
}
@SuppressWarnings({"deprecation"})
private IAnnotation createTestTag(Class cls, Annotation a,
IAnnotationTransformer transformer)
{
TestAnnotation result = new TestAnnotation();
Test test = (Test) a;
result.setEnabled(test.enabled());
result.setGroups(join(test.groups(), findInheritedStringArray(cls, Test.class, "groups")));
result.setParameters(test.parameters());
result.setDependsOnGroups(join(test.dependsOnGroups(),
findInheritedStringArray(cls, Test.class, "dependsOnGroups")));
result.setDependsOnMethods(join(test.dependsOnMethods(),
findInheritedStringArray(cls, Test.class, "dependsOnMethods")));
result.setTimeOut(test.timeOut());
result.setInvocationCount(test.invocationCount());
result.setThreadPoolSize(test.threadPoolSize());
result.setSuccessPercentage(test.successPercentage());
result.setDataProvider(test.dataProvider());
result.setDataProviderClass(test.dataProviderClass() != Object.class ?
test.dataProviderClass() : null);
result.setAlwaysRun(test.alwaysRun());
result.setDescription(test.description());
result.setExpectedExceptions(test.expectedExceptions());
result.setSuiteName(test.suiteName());
result.setTestName(test.testName());
result.setSequential(test.sequential());
return result;
}
private String[] join(String[] strings, String[] strings2) {
Map<String, String> vResult = new HashMap<String, String>();
for (String s : strings) {
vResult.put(s, s);
}
for (String s : strings2) {
vResult.put(s, s);
}
return vResult.keySet().toArray(new String[vResult.size()]);
}
private String[] findInheritedStringArray(Class cls, Class annotationClass, String methodName)
{
if (null == cls) return new String[0];
Map<String, String> vResult = new HashMap<String, String>();
while (cls != null && cls != Object.class) {
Annotation annotation = cls.getAnnotation(annotationClass);
if (annotation != null) {
String[] g = (String[]) invokeMethod(annotation, methodName);
for (String s : g) {
vResult.put(s, s);
}
}
cls = cls.getSuperclass();
}
String[] result = vResult.keySet().toArray(new String[vResult.size()]);
return result;
}
private Object invokeMethod(Annotation test, String methodName) {
Object result = null;
try {
// Note: we should cache methods already looked up
Method m = test.getClass().getMethod(methodName, new Class[0]);
result = m.invoke(test, new Object[0]);
}
catch (Exception e) {
e.printStackTrace();
}
return result;
}
private void ppp(String string) {
System.out.println("[JDK15TagFactory] " + string);
}
}