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.Collection;
|
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.IClassListener;
|
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(XmlSuite.ParallelMode 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,
|
Collection<IInvokedMethodListener> listeners, List<IClassListener> classListeners) {
|
TestRunner testRunner= new TestRunner(m_baseTest.getConfiguration(), suite, test, false,
|
listeners, classListeners);
|
|
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
|
