package test; | |
import java.io.BufferedReader; | |
import java.io.File; | |
import java.io.FileReader; | |
import java.io.IOException; | |
import java.util.ArrayList; | |
import java.util.Arrays; | |
import java.util.HashMap; | |
import java.util.List; | |
import java.util.Map; | |
import java.util.Set; | |
import java.util.regex.Pattern; | |
import org.testng.Assert; | |
import org.testng.IInvokedMethodListener; | |
import org.testng.ISuite; | |
import org.testng.ITestResult; | |
import org.testng.ITestRunnerFactory; | |
import org.testng.SuiteRunner; | |
import org.testng.TestListenerAdapter; | |
import org.testng.TestRunner; | |
import org.testng.annotations.BeforeMethod; | |
import org.testng.collections.Lists; | |
import org.testng.internal.Configuration; | |
import org.testng.internal.IConfiguration; | |
import org.testng.reporters.JUnitXMLReporter; | |
import org.testng.reporters.TestHTMLReporter; | |
import org.testng.xml.XmlClass; | |
import org.testng.xml.XmlInclude; | |
import org.testng.xml.XmlMethodSelector; | |
import org.testng.xml.XmlPackage; | |
import org.testng.xml.XmlSuite; | |
import org.testng.xml.XmlTest; | |
/** | |
* Base class for tests | |
* | |
* @author Cedric Beust, May 5, 2004 | |
* | |
*/ | |
public class BaseTest extends BaseDistributedTest { | |
private static final String m_outputDirectory= "test-output-tests"; | |
private XmlSuite m_suite= null; | |
private ITestRunnerFactory m_testRunnerFactory; | |
private IConfiguration m_configuration; | |
private Integer m_verbose = null; | |
public BaseTest() { | |
m_testRunnerFactory= new InternalTestRunnerFactory(this); | |
m_configuration = new Configuration(); | |
} | |
private IConfiguration getConfiguration() { | |
return m_configuration; | |
} | |
protected void setDebug() { | |
getTest().setVerbose(9); | |
} | |
protected void setParallel(String parallel) { | |
getTest().setParallel(parallel); | |
} | |
protected void setVerbose(int n) { | |
m_verbose = n; | |
} | |
protected void setTestTimeOut(long n) { | |
getTest().setTimeOut(n); | |
} | |
protected void setSuiteTimeOut(long n) { | |
m_suite.setTimeOut(Long.toString(n)); | |
} | |
protected void setJUnit(boolean f) { | |
getTest().setJUnit(f); | |
} | |
protected void setThreadCount(int count) { | |
getTest().getSuite().setThreadCount(count); | |
} | |
private Map<Long, XmlTest> m_tests= new HashMap<>(); | |
private Map<Long, Map> m_passedTests= new HashMap<>(); | |
private Map<Long, Map> m_failedTests= new HashMap<>(); | |
private Map<Long, Map> m_skippedTests= new HashMap<>(); | |
private Map<Long, XmlTest> m_testConfigs= new HashMap<>(); | |
private Map<Long, Map> m_passedConfigs= new HashMap<>(); | |
private Map<Long, Map> m_failedConfigs= new HashMap<>(); | |
private Map<Long, Map> m_skippedConfigs= new HashMap<>(); | |
private Map<Long, Map> m_failedButWithinSuccessPercentageTests= new HashMap<>(); | |
protected Map<String, List<ITestResult>> getTests(Map<Long, Map> map) { | |
Map<String, List<ITestResult>> result= map.get(getId()); | |
if(null == result) { | |
result= new HashMap<>(); | |
map.put(getId(), result); | |
} | |
return result; | |
} | |
protected XmlTest getTest() { | |
return m_tests.get(getId()); | |
} | |
protected void setTests(Map<Long, Map> map, Map m) { | |
map.put(getId(), m); | |
} | |
public Map<String, List<ITestResult>> getFailedTests() { | |
return getTests(m_failedTests); | |
} | |
public Map<String, List<ITestResult>> getFailedButWithinSuccessPercentageTests() { | |
return getTests(m_failedButWithinSuccessPercentageTests); | |
} | |
public Map<String, List<ITestResult>> getPassedTests() { | |
return getTests(m_passedTests); | |
} | |
public Map<String, List<ITestResult>> getSkippedTests() { | |
return getTests(m_skippedTests); | |
} | |
public Map<String, List<ITestResult>> getFailedConfigs() { | |
return getTests(m_failedConfigs); | |
} | |
public Map<String, List<ITestResult>> getPassedConfigs() { | |
return getTests(m_passedConfigs); | |
} | |
public Map<String, List<ITestResult>> getSkippedConfigs() { | |
return getTests(m_skippedConfigs); | |
} | |
public void setSkippedTests(Map m) { | |
setTests(m_skippedTests, m); | |
} | |
public void setPassedTests(Map m) { | |
setTests(m_passedTests, m); | |
} | |
public void setFailedTests(Map m) { | |
setTests(m_failedTests, m); | |
} | |
public void setFailedButWithinSuccessPercentageTests(Map m) { | |
setTests(m_failedButWithinSuccessPercentageTests, m); | |
} | |
public void setSkippedConfigs(Map m) { | |
setTests(m_skippedConfigs, m); | |
} | |
public void setPassedConfigs(Map m) { | |
setTests(m_passedConfigs, m); | |
} | |
public void setFailedConfigs(Map m) { | |
setTests(m_failedConfigs, m); | |
} | |
protected void run() { | |
assert null != getTest() : "Test wasn't set, maybe @Configuration methodSetUp() was never called"; | |
setPassedTests(new HashMap()); | |
setFailedTests(new HashMap()); | |
setSkippedTests(new HashMap()); | |
setPassedConfigs(new HashMap()); | |
setFailedConfigs(new HashMap()); | |
setSkippedConfigs(new HashMap()); | |
setFailedButWithinSuccessPercentageTests(new HashMap()); | |
m_suite.setVerbose(m_verbose != null ? m_verbose : 0); | |
SuiteRunner suite = new SuiteRunner(m_configuration, | |
m_suite, m_outputDirectory, m_testRunnerFactory); | |
suite.run(); | |
} | |
protected void addMethodSelector(String className, int priority) { | |
XmlMethodSelector methodSelector= new XmlMethodSelector(); | |
methodSelector.setName(className); | |
methodSelector.setPriority(priority); | |
getTest().getMethodSelectors().add(methodSelector); | |
} | |
protected XmlClass addClass(Class<?> cls) { | |
return addClass(cls.getName()); | |
} | |
protected XmlClass addClass(String className) { | |
XmlClass result= new XmlClass(className); | |
getTest().getXmlClasses().add(result); | |
return result; | |
} | |
protected void setBeanShellExpression(String expression) { | |
getTest().setBeanShellExpression(expression); | |
} | |
protected void addPackage(String pkgName, String[] included, String[] excluded) { | |
XmlPackage pkg= new XmlPackage(); | |
pkg.setName(pkgName); | |
pkg.getInclude().addAll(Arrays.asList(included)); | |
pkg.getExclude().addAll(Arrays.asList(excluded)); | |
getTest().getSuite().getXmlPackages().add(pkg); | |
} | |
private XmlClass findClass(String className) { | |
for(XmlClass cl : getTest().getXmlClasses()) { | |
if(cl.getName().equals(className)) { | |
return cl; | |
} | |
} | |
XmlClass result= addClass(className); | |
return result; | |
} | |
public void addIncludedMethod(String className, String m) { | |
XmlClass xmlClass= findClass(className); | |
xmlClass.getIncludedMethods().add(new XmlInclude(m)); | |
getTest().getXmlClasses().add(xmlClass); | |
} | |
public void addExcludedMethod(String className, String m) { | |
XmlClass xmlClass= findClass(className); | |
xmlClass.getExcludedMethods().add(m); | |
getTest().getXmlClasses().add(xmlClass); | |
} | |
public void addIncludedGroup(String g) { | |
getTest().addIncludedGroup(g); | |
} | |
public void addExcludedGroup(String g) { | |
getTest().addExcludedGroup(g); | |
} | |
public void addMetaGroup(String mg, List<String> l) { | |
getTest().getMetaGroups().put(mg, l); | |
} | |
public void addMetaGroup(String mg, String n) { | |
List<String> l= new ArrayList<>(); | |
l.add(n); | |
addMetaGroup(mg, l); | |
} | |
public void setParameter(String key, String value) { | |
getTest().addParameter(key, value); | |
} | |
// @Configuration(beforeTestMethod = true, groups = { "init", "initTest"}) | |
@BeforeMethod(groups= { "init", "initTest" }) | |
public void methodSetUp() { | |
m_suite= new XmlSuite(); | |
m_suite.setName("Internal_suite"); | |
XmlTest xmlTest= new XmlTest(m_suite); | |
xmlTest.setName("Internal_test_failures_are_expected"); | |
m_tests.put(getId(), xmlTest); | |
} | |
private void addTest(Map<String, List<ITestResult>> tests, ITestResult t) { | |
List<ITestResult> l= tests.get(t.getMethod().getMethodName()); | |
if(null == l) { | |
l= new ArrayList<>(); | |
tests.put(t.getMethod().getMethodName(), l); | |
} | |
l.add(t); | |
} | |
public void addPassedTest(ITestResult t) { | |
addTest(getPassedTests(), t); | |
} | |
public void addFailedTest(ITestResult t) { | |
addTest(getFailedTests(), t); | |
} | |
public void addFailedButWithinSuccessPercentageTest(ITestResult t) { | |
addTest(getFailedButWithinSuccessPercentageTests(), t); | |
} | |
public void addSkippedTest(ITestResult t) { | |
addTest(getSkippedTests(), t); | |
} | |
public void addPassedConfig(ITestResult t) { | |
addTest(getPassedConfigs(), t); | |
} | |
public void addFailedConfig(ITestResult t) { | |
addTest(getFailedConfigs(), t); | |
} | |
public void addSkippedConfig(ITestResult t) { | |
addTest(getSkippedConfigs(), t); | |
} | |
private void ppp(String s) { | |
System.out.println("[BaseTest " + getId() + "] " + s); | |
} | |
protected Long getId() { | |
return 42L; | |
// long result = Thread.currentThread().getId(); | |
//// System.out.println("RETURNING ID " + result); | |
// return result; | |
} | |
public XmlSuite getSuite() { | |
return m_suite; | |
} | |
public void setSuite(XmlSuite suite) { | |
m_suite = suite; | |
} | |
/** | |
* Used for instanceCount testing, when we need to look inside the | |
* TestResult to count the various SUCCESS/FAIL/FAIL_BUT_OK | |
*/ | |
protected void verifyResults(Map<String, List<ITestResult>> tests, | |
int expected, | |
String message) { | |
if(tests.size() > 0) { | |
Set keys= tests.keySet(); | |
Object firstKey= keys.iterator().next(); | |
List<ITestResult> passedResult= tests.get(firstKey); | |
int n= passedResult.size(); | |
assert n == expected : "Expected " + expected + " " + message + " but found " + n; | |
} | |
else { | |
assert expected == 0 : "Expected " + expected + " " + message + " but found " | |
+ tests.size(); | |
} | |
} | |
protected void dumpResults(String name, Map<String, List<ITestResult>> tests) { | |
ppp("============= " + name); | |
for(Map.Entry<String, List<ITestResult>> entry : tests.entrySet()) { | |
ppp("TEST:" + entry.getKey()); | |
List<ITestResult> l= entry.getValue(); | |
for(ITestResult tr : l) { | |
ppp(" " + tr); | |
} | |
} | |
} | |
protected static void verifyInstanceNames(String title, Map<String, List<ITestResult>> actual, | |
String[] expected) | |
{ | |
List<String> actualNames = Lists.newArrayList(); | |
for (Map.Entry<String, List<ITestResult>> es : actual.entrySet()) { | |
for (ITestResult tr : es.getValue()) { | |
Object instance = tr.getInstance(); | |
actualNames.add(es.getKey() + "#" + (instance != null ? instance.toString() : "")); | |
} | |
} | |
Assert.assertEqualsNoOrder(actualNames.toArray(), expected); | |
} | |
protected void verifyPassedTests(String... expectedPassed) { | |
verifyTests("Passed", expectedPassed, getPassedTests()); | |
} | |
protected void verifyFailedTests(String... expectedFailed) { | |
verifyTests("Failed", expectedFailed, getFailedTests()); | |
} | |
/** | |
* | |
* @param fileName The filename to parse | |
* @param regexp The regular expression | |
* @param resultLines An out parameter that will contain all the lines | |
* that matched the regexp | |
* @return A List<Integer> containing the lines of all the matches | |
* | |
* Note that the size() of the returned valuewill always be equal to | |
* result.size() at the end of this function. | |
*/ | |
public static List<Integer> grep(File fileName, String regexp, List<String> resultLines) { | |
List<Integer> resultLineNumbers = new ArrayList<>(); | |
BufferedReader fr = null; | |
try { | |
fr = new BufferedReader(new FileReader(fileName)); | |
String line = fr.readLine(); | |
int currentLine = 0; | |
Pattern p = Pattern.compile(".*" + regexp + ".*"); | |
while(null != line) { | |
// ppp("COMPARING " + p + " TO @@@" + line + "@@@"); | |
if(p.matcher(line).matches()) { | |
resultLines.add(line); | |
resultLineNumbers.add(currentLine); | |
} | |
line = fr.readLine(); | |
currentLine++; | |
} | |
} catch(IOException e) { | |
e.printStackTrace(); | |
} | |
finally { | |
if(null != fr) { | |
try { | |
fr.close(); | |
} | |
catch(IOException ex) { | |
ex.printStackTrace(); | |
} | |
} | |
} | |
return resultLineNumbers; | |
} | |
private static class InternalTestRunnerFactory implements ITestRunnerFactory { | |
private final BaseTest m_baseTest; | |
public InternalTestRunnerFactory(final BaseTest baseTest) { | |
m_baseTest= baseTest; | |
} | |
/** | |
* @see org.testng.ITestRunnerFactory#newTestRunner(org.testng.ISuite, org.testng.xml.XmlTest) | |
*/ | |
@Override | |
public TestRunner newTestRunner(ISuite suite, XmlTest test, | |
List<IInvokedMethodListener> listeners) { | |
TestRunner testRunner= new TestRunner(m_baseTest.getConfiguration(), suite, test, false, | |
listeners); | |
testRunner.addTestListener(new TestHTMLReporter()); | |
testRunner.addTestListener(new JUnitXMLReporter()); | |
testRunner.addListener(new TestListener(m_baseTest)); | |
if (listeners != null) { | |
for (IInvokedMethodListener l : listeners) { | |
testRunner.addListener(l); | |
} | |
} | |
return testRunner; | |
} | |
} | |
/** | |
* Deletes all files and subdirectories under dir. | |
* @return true if all deletions were successful. | |
* If a deletion fails, the method stops attempting to delete and returns false. | |
*/ | |
public static boolean deleteDir(File dir) { | |
if (dir.isDirectory()) { | |
String[] children = dir.list(); | |
for (String element : children) { | |
boolean success = deleteDir(new File(dir, element)); | |
if (!success) { | |
return false; | |
} | |
} | |
} | |
// The directory is now empty so delete it | |
return dir.delete(); | |
} | |
protected void runTest(String cls, String[] passed, String[] failed, String[] skipped) { | |
addClass(cls); | |
run(); | |
verifyTests("Passed", passed, getPassedTests()); | |
verifyTests("Failed", failed, getFailedTests()); | |
verifyTests("Skipped", skipped, getSkippedTests()); | |
} | |
} // BaseTest | |
//////////////////////////// | |
class TestListener extends TestListenerAdapter { | |
private static BaseTest m_test= null; | |
public TestListener(BaseTest t1) { | |
m_test= t1; | |
} | |
@Override | |
public void onTestSuccess(ITestResult tr) { | |
m_test.addPassedTest(tr); | |
} | |
@Override | |
public void onTestFailure(ITestResult tr) { | |
m_test.addFailedTest(tr); | |
} | |
@Override | |
public void onTestFailedButWithinSuccessPercentage(ITestResult result) { | |
m_test.addFailedButWithinSuccessPercentageTest(result); | |
} | |
@Override | |
public void onTestSkipped(ITestResult tr) { | |
m_test.addSkippedTest(tr); | |
} | |
@Override | |
public void onConfigurationSuccess(ITestResult tr) { | |
m_test.addPassedConfig(tr); | |
} | |
@Override | |
public void onConfigurationFailure(ITestResult tr) { | |
m_test.addFailedConfig(tr); | |
} | |
@Override | |
public void onConfigurationSkip(ITestResult tr) { | |
m_test.addSkippedConfig(tr); | |
} | |
} // TestListener |