package org.testng.xml;
import org.testng.collections.Lists;
import org.testng.collections.Maps;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.ServiceLoader;
public class Parser {
public static final String TESTNG_DTD = "testng-1.0.dtd";
public static final String DEPRECATED_TESTNG_DTD_URL = "http://beust.com/testng/" + TESTNG_DTD;
public static final String TESTNG_DTD_URL = "http://testng.org/" + TESTNG_DTD;
public static final String DEFAULT_FILENAME = "testng.xml";
private static final ISuiteParser DEFAULT_FILE_PARSER = new SuiteXmlParser();
private static final List<ISuiteParser> PARSERS = Lists.newArrayList();
static {
ServiceLoader<ISuiteParser> suiteParserLoader = ServiceLoader.load(ISuiteParser.class);
for (ISuiteParser parser : suiteParserLoader) {
PARSERS.add(parser);
}
}
private String m_fileName;
private InputStream m_inputStream;
private IPostProcessor m_postProcessor;
private boolean m_loadClasses = true;
public Parser(String fileName) {
init(fileName, null);
}
public Parser() throws FileNotFoundException {
init(null, null);
}
public Parser(InputStream is) {
init(null, is);
}
private void init(String fileName, InputStream is) {
m_fileName = fileName != null ? fileName : DEFAULT_FILENAME;
m_inputStream = is;
}
public void setPostProcessor(IPostProcessor processor) {
m_postProcessor = processor;
}
public void setLoadClasses(boolean loadClasses) {
m_loadClasses = loadClasses;
}
private static IFileParser getParser(String fileName) {
for (ISuiteParser parser : PARSERS) {
if (parser.accept(fileName)) {
return parser;
}
}
return DEFAULT_FILE_PARSER;
}
public Collection<XmlSuite> parse() throws IOException {
List<String> processedSuites = Lists.newArrayList();
XmlSuite resultSuite = null;
List<String> toBeParsed = Lists.newArrayList();
List<String> toBeAdded = Lists.newArrayList();
List<String> toBeRemoved = Lists.newArrayList();
if (m_fileName != null) {
URI uri = constructURI(m_fileName);
if (uri == null || uri.getScheme() == null) {
uri = new File(m_fileName).toURI();
}
if ("file".equalsIgnoreCase(uri.getScheme())) {
File mainFile = new File(uri);
toBeParsed.add(mainFile.getCanonicalPath());
} else {
toBeParsed.add(uri.toString());
}
}
Map<String, XmlSuite> childToParentMap = Maps.newHashMap();
while (!toBeParsed.isEmpty()) {
for (String currentFile : toBeParsed) {
File parentFile = null;
InputStream inputStream = null;
if (hasFileScheme(currentFile)) {
File currFile = new File(currentFile);
parentFile = currFile.getParentFile();
inputStream = m_inputStream != null ? m_inputStream : new FileInputStream(currFile);
}
IFileParser<XmlSuite> fileParser = getParser(currentFile);
XmlSuite currentXmlSuite = fileParser.parse(currentFile, inputStream, m_loadClasses);
currentXmlSuite.setParsed(true);
processedSuites.add(currentFile);
toBeRemoved.add(currentFile);
if (childToParentMap.containsKey(currentFile)) {
XmlSuite parentSuite = childToParentMap.get(currentFile);
currentXmlSuite.setParentSuite(parentSuite);
parentSuite.getChildSuites().add(currentXmlSuite);
}
if (null == resultSuite) {
resultSuite = currentXmlSuite;
}
List<String> suiteFiles = currentXmlSuite.getSuiteFiles();
if (!suiteFiles.isEmpty()) {
for (String path : suiteFiles) {
String canonicalPath = path;
if (hasFileScheme(path)) {
if (parentFile != null && new File(parentFile, path).exists()) {
canonicalPath = new File(parentFile, path).getCanonicalPath();
} else {
canonicalPath = new File(path).getCanonicalPath();
}
}
if (!processedSuites.contains(canonicalPath)) {
toBeAdded.add(canonicalPath);
childToParentMap.put(canonicalPath, currentXmlSuite);
}
}
}
}
toBeParsed.removeAll(toBeRemoved);
toBeRemoved = Lists.newArrayList();
toBeParsed.addAll(toBeAdded);
toBeAdded = Lists.newArrayList();
}
List<XmlSuite> resultList = Lists.newArrayList();
resultList.add(resultSuite);
if (m_postProcessor != null) {
return m_postProcessor.process(resultList);
} else {
return resultList;
}
}
public static boolean hasFileScheme(String uri) {
URI constructedURI = constructURI(uri);
if (constructedURI == null) {
return true;
}
String scheme = constructedURI.getScheme();
return scheme == null || "file".equalsIgnoreCase(scheme);
}
public List<XmlSuite> parseToList() throws IOException {
return Lists.newArrayList(parse());
}
public static Collection<XmlSuite> parse(String suite, IPostProcessor processor) throws IOException {
return newParser(suite, processor).parse();
}
public static Collection<XmlSuite> parse(InputStream is, IPostProcessor processor) throws IOException {
return newParser(is, processor).parse();
}
public static boolean canParse(String fileName) {
for (ISuiteParser parser : PARSERS) {
if (parser.accept(fileName)) {
return true;
}
}
return DEFAULT_FILE_PARSER.accept(fileName);
}
private static Parser newParser(String path, IPostProcessor processor) {
Parser result = new Parser(path);
result.setPostProcessor(processor);
return result;
}
private static Parser newParser(InputStream is, IPostProcessor processor) {
Parser result = new Parser(is);
result.setPostProcessor(processor);
return result;
}
private static URI constructURI(String text) {
try {
return URI.create(text);
} catch (Exception e) {
return null;
}
}
}