| package org.testng.junit; |
| |
| import org.testng.ITestMethodFinder; |
| import org.testng.ITestNGMethod; |
| import org.testng.collections.Lists; |
| import org.testng.internal.TestNGMethod; |
| import org.testng.internal.annotations.IAnnotationFinder; |
| import org.testng.xml.XmlTest; |
| |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| |
| /** |
| * This class locates all test and configuration methods according to JUnit. |
| * It is used to change the strategy used by TestRunner to locate its test |
| * methods. |
| * |
| * @author Cedric Beust, May 3, 2004 |
| * |
| */ |
| public class JUnitMethodFinder implements ITestMethodFinder { |
| private String m_testName = null; |
| private IAnnotationFinder m_annotationFinder = null; |
| |
| public JUnitMethodFinder(String testName, IAnnotationFinder finder) { |
| m_testName = testName; |
| m_annotationFinder = finder; |
| } |
| |
| private Constructor findConstructor(Class cls, Class[] parameters) { |
| Constructor result = null; |
| |
| try { |
| result = cls.getConstructor(parameters); |
| } |
| catch (SecurityException ex) { |
| // ignore |
| } |
| catch (NoSuchMethodException ex) { |
| // ignore |
| } |
| |
| return result; |
| } |
| |
| public ITestNGMethod[] getTestMethods(Class cls, XmlTest xmlTest) { |
| ITestNGMethod[] result = |
| privateFindTestMethods(new INameFilter() { |
| public boolean accept(Method method) { |
| return method.getName().startsWith("test") && |
| method.getParameterTypes().length == 0; |
| } |
| }, cls); |
| |
| // ppp("====="); |
| // ppp("FIND TEST METHOD RETURNING "); |
| // for (ITestMethod m : result) { |
| // ppp(" " + m); |
| // } |
| // ppp("====="); |
| return result; |
| } |
| |
| private ITestNGMethod[] privateFindTestMethods(INameFilter filter, Class cls) { |
| List<ITestNGMethod> vResult = Lists.newArrayList(); |
| |
| // We do not want to walk up the class hierarchy and accept the |
| // same method twice (e.g. setUp) which would lead to double-invocation. |
| // All relevant JUnit methods are parameter-less so we store accepted |
| // method names in a Set to filter out duplicates. |
| Set<String> acceptedMethodNames = new HashSet<String>(); |
| |
| // |
| // Collect all methods that start with test |
| // |
| Class current = cls; |
| while(!(current == Object.class)) { |
| Method[] allMethods = current.getDeclaredMethods(); |
| for(Method allMethod : allMethods) { |
| ITestNGMethod m = new TestNGMethod(/* allMethods[i].getDeclaringClass(), */ allMethod, |
| m_annotationFinder, null); |
| Method method = m.getMethod(); |
| String methodName = method.getName(); |
| if(filter.accept(method) && !acceptedMethodNames.contains(methodName)) { |
| // if (m.getName().startsWith("test")) { |
| // ppp("Found JUnit test method: " + tm); |
| vResult.add(m); |
| acceptedMethodNames.add(methodName); |
| } |
| } |
| current = current.getSuperclass(); |
| } |
| |
| return vResult.toArray(new ITestNGMethod[vResult.size()]); |
| } |
| |
| private static void ppp(String s) { |
| System.out.println("[JUnitMethodFinder] " + s); |
| } |
| |
| private Object instantiate(Class cls) { |
| Object result = null; |
| |
| Constructor ctor = findConstructor(cls, new Class[] { String.class }); |
| try { |
| if (null != ctor) { |
| result = ctor.newInstance(new Object[] { m_testName }); |
| } |
| else { |
| ctor = cls.getConstructor(new Class[0]); |
| result = ctor.newInstance(new Object[0]); |
| } |
| } |
| catch (IllegalArgumentException ex) { |
| ex.printStackTrace(); |
| } |
| catch (SecurityException ex) { |
| ex.printStackTrace(); |
| } |
| catch (InstantiationException ex) { |
| System.err.println("Couldn't find a constructor with a String parameter on your JUnit test class."); |
| ex.printStackTrace(); |
| } |
| catch (IllegalAccessException ex) { |
| ex.printStackTrace(); |
| } |
| catch (InvocationTargetException ex) { |
| ex.printStackTrace(); |
| } |
| catch (NoSuchMethodException ex) { |
| ex.printStackTrace(); |
| } |
| |
| return result; |
| } |
| |
| |
| public ITestNGMethod[] getBeforeTestMethods(Class cls) { |
| ITestNGMethod[] result = privateFindTestMethods(new INameFilter() { |
| public boolean accept(Method method) { |
| return "setUp".equals(method.getName()); |
| } |
| }, cls); |
| |
| return result; |
| } |
| |
| public ITestNGMethod[] getAfterTestMethods(Class cls) { |
| ITestNGMethod[] result = privateFindTestMethods(new INameFilter() { |
| public boolean accept(Method method) { |
| return "tearDown".equals(method.getName()); |
| } |
| }, cls); |
| |
| return result; |
| } |
| |
| public ITestNGMethod[] getAfterClassMethods(Class cls) { |
| return new ITestNGMethod[0]; |
| } |
| |
| public ITestNGMethod[] getBeforeClassMethods(Class cls) { |
| return new ITestNGMethod[0]; |
| } |
| |
| public ITestNGMethod[] getBeforeSuiteMethods(Class cls) { |
| return new ITestNGMethod[0]; |
| } |
| |
| public ITestNGMethod[] getAfterSuiteMethods(Class cls) { |
| return new ITestNGMethod[0]; |
| } |
| |
| public ITestNGMethod[] getBeforeTestConfigurationMethods(Class testClass) { |
| return new ITestNGMethod[0]; |
| } |
| |
| public ITestNGMethod[] getAfterTestConfigurationMethods(Class testClass) { |
| return new ITestNGMethod[0]; |
| } |
| |
| public ITestNGMethod[] getBeforeGroupsConfigurationMethods(Class testClass) { |
| return new ITestNGMethod[0]; |
| } |
| |
| public ITestNGMethod[] getAfterGroupsConfigurationMethods(Class testClass) { |
| return new ITestNGMethod[0]; |
| } |
| } |
| |
| ///////////// |
| |
| interface INameFilter { |
| public boolean accept(Method method); |
| } |