package org.test4j.spec.util;
import java.util.List;
import org.test4j.hamcrest.matcher.string.StringMode;
import org.test4j.spec.util.MethodNodeParser;
import org.test4j.spec.util.XmlHelper.MethodNode;
import org.test4j.testng.Test4J;
import org.test4j.tools.commons.ResourceHelper;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
public class MethodNodeParserTest extends Test4J {
@Test(dataProvider = "dataForIsParaBegin")
public void testParseParameterName(String input, String paraName) throws Exception {
MethodNodeParser parser = new MethodNodeParser(input);
MethodNode para = parser.parseParameterName(0);
want.object(para).propertyEq("paraName", paraName);
char ch = parser.currIndexChar();
want.character(ch).is('a');
}
@DataProvider
public DataIterator dataForIsParaBegin() {
return new DataIterator() {
{
data("name=\"name\">a", "name");
data(" name = \"nam e \" >a", "nam e ");
}
};
}
public void testIsBgnParaElement_NotBegin() throws Exception {
MethodNodeParser parser = new MethodNodeParser("<part name");
boolean isBegin = parser.isBgnParaElement(0);
want.bool(isBegin).is(false);
want.object(parser).propertyEq("currIndex", 0);
}
public void testIsBgnParaElement() throws Exception {
MethodNodeParser parser = new MethodNodeParser("<para name");
boolean isBegin = parser.isBgnParaElement(0);
want.bool(isBegin).is(true);
want.object(parser).propertyEq("currIndex", 6);
}
@Test(dataProvider = "dataForIsParaBegin_Illegal")
public void testParseParameterName_Illegal(String input, String expected) throws Exception {
MethodNodeParser parser = new MethodNodeParser(input);
try {
parser.parseParameterName(0);
want.fail();
} catch (RuntimeException e) {
String error = e.getMessage();
want.string(error).contains(expected, StringMode.IgnoreSpace);
}
}
@DataProvider
public DataIterator dataForIsParaBegin_Illegal() {
return new DataIterator() {
{
data("nane", "only name property allowed by para element");
data(" name+", "expected char('=')");
data(" name = '", "expected char('\"')");
data(" name=\"name\"a", "expected char('>')");
data(" name=\"\">", "the name of para can't be null!");
}
};
}
@Test(dataProvider = "dataForIsEndParaElement")
public void testIsEndParaElement(String input, boolean expected, int currIndex) throws Exception {
MethodNodeParser parser = new MethodNodeParser(input);
boolean isEnd = parser.isEndParaElement(0);
want.bool(isEnd).is(expected);
want.object(parser).propertyEq("currIndex", currIndex);
}
@DataProvider
public DataIterator dataForIsEndParaElement() {
return new DataIterator() {
{
data("</para>xxx", true, 7);
data("< / para >xxx", true, 10);
data("<\\para>xxx", false, 0);
data("</part>xxx", false, 0);
}
};
}
@Test(dataProvider = "dataForParseParaValue")
public void testParseParameterValue(String input, String expected) throws Exception {
MethodNodeParser parser = new MethodNodeParser(input);
MethodNode paraNode = new MethodNode(true);
parser.parseParameterValue(paraNode, 0);
want.object(paraNode).propertyEq("text", expected);
char ch = parser.currIndexChar();
want.character(ch).is('x');
}
@DataProvider
public static DataIterator dataForParseParaValue() {
return new DataIterator() {
{
data("abc</para>x", "abc");
data("abc< / para >x", "abc");
data("xb<part>c</para>x", "xb<part>c");
data("xb</part>c</para>x", "xb</part>c");
data("<abc</para>x", "<abc");
data("<![CDATA[abc]]></para>x", "abc");
data("<![CDA TA[abc] ]></para>x", "<![CDA TA[abc] ]>");
}
};
}
@Test(dataProvider = "dataForParseParaValue_Exception")
public void testParseParameterValue_Exception(String input, String expected) throws Exception {
MethodNodeParser parser = new MethodNodeParser(input);
MethodNode paraNode = new MethodNode(true);
try {
parser.parseParameterValue(paraNode, 0);
want.fail();
} catch (RuntimeException e) {
String error = e.getMessage();
want.string(error).contains(expected, StringMode.IgnoreSpace, StringMode.SameAsQuato);
}
}
@DataProvider
public static DataIterator dataForParseParaValue_Exception() {
return new DataIterator() {
{
data("xbc<para>x", "you haven't end with previous para element");
data("<![CDATA[xbc]]> x</para>x", "expected end of para element at index");
data("<![CDATA[xbc</para>x", "ou have '<![CDATA[' begin of para value, but not end with ']]>'");
data("xbc]]></para>x", "you have ']]>' end of para value, but not begin with '<![CDATA['");
data("<![CDATA[xbc]]>", "The element type 'para' must be terminated by the matching end-tag '</para>'");
}
};
}
@Test(dataProvider = "dataForParseMethodNodes")
public void testParseMethodNodes(String fileNo, MethodNode[] expected) throws Exception {
String text = ResourceHelper
.readFromFile(MethodNodeParserTest.class, "testParseMethodNodes_" + fileNo + ".txt");
MethodNodeParser parser = new MethodNodeParser(text);
List<MethodNode> nodes = parser.parseMethodNodes();
want.list(nodes).reflectionEq(expected);
}
@DataProvider
public DataIterator dataForParseMethodNodes() {
return new DataIterator() {
{
data("01", new MethodNode[] { new MethodNode("asdfsdaf\n"), new MethodNode("name1", "asdfsadf"),
new MethodNode("\nasdfsadf") });
data("02", new MethodNode[] { new MethodNode("asdfsdaf\n"), new MethodNode("name1", "asdfsadf"),
new MethodNode("name2", "asdfsadf") });
}
};
}
}