public void ParseAssignmentTest()
{
//Create parser
StatementParser statementParser = new StatementParser(Init("var1 = \"test\";"));
Assignment parsedAssignment = statementParser.ParseAssignment();
//Test assignment
Assert.AreEqual(typeof(VarBindAssignment), parsedAssignment.GetType());
//Test VarBindAssignment
VarBindAssignment parsedVarAssignment = (VarBindAssignment)parsedAssignment;
Assert.AreEqual("var1", parsedVarAssignment.GetIdentifier());
Assert.AreEqual(typeof(TextExpression), parsedVarAssignment.GetExpression().GetType());
Assert.AreEqual("\"test\"", parsedVarAssignment.GetExpression().ToString());
}
public void ParseBlockStatementTest()
{
//Create parser
StatementParser statementParser = new StatementParser(Init("{\n\techo \"test\";\n}"));
Statement parsedStatement = statementParser.ParseStatement();
//Test statement
Assert.AreEqual(typeof(BlockStatement), parsedStatement.GetType());
//Test BlockStatement
BlockStatement statement = (BlockStatement)parsedStatement;
Assert.AreEqual(1, statement.GetStatements().Count);
//Test substatement
List<ISyntaxNode>.Enumerator statementEnum = statement.GetStatements().GetEnumerator();
statementEnum.MoveNext();
Assert.AreEqual(typeof(EchoExpressionStatement), statementEnum.Current.GetType());
Assert.AreEqual("echo \"test\";", statementEnum.Current.ToString());
}
public void ParseYieldStatementTest()
{
//Create parser
StatementParser statementParser = new StatementParser(Init("yield;"));
YieldStatement parsedYield = statementParser.ParseYieldStatement();
//Test yield instance
Assert.AreEqual(typeof(YieldStatement), parsedYield.GetType());
Assert.AreEqual("yield;", parsedYield.ToString());
}
public void ParseMarkupStatStatementTest()
{
//Create parser
StatementParser statementParser = new StatementParser(Init("p { echo \"test\"; }"));
Statement parsedStatement = statementParser.ParseMarkupStatement();
//Test Statement
Assert.AreEqual(typeof(MarkupStatStatement), parsedStatement.GetType());
//Test MarkupStatStatement
MarkupStatStatement markupStatStatement = (MarkupStatStatement)parsedStatement;
Assert.AreEqual(1, markupStatStatement.GetMarkups().Count);
//Test markup
Markup markup = (Markup) markupStatStatement.GetMarkups().Get(0);
Assert.AreEqual("p", markup.GetDesignator().GetIdentifier());
Assert.AreEqual(0, markup.GetArguments().Count);
//Test statement
Assert.AreEqual(typeof(BlockStatement), markupStatStatement.GetStatement().GetType());
BlockStatement statement = (BlockStatement)markupStatStatement.GetStatement();
Assert.AreEqual(1, statement.GetStatements().Count);
Statement stmt = (Statement) statement.GetStatements().Get(0);
Assert.AreEqual(typeof(EchoExpressionStatement), stmt.GetType());
Assert.AreEqual("echo \"test\";", stmt.ToString());
}
public void ParserMarkupEmbeddingStatementTest()
{
//Create parser
StatementParser statementParser = new StatementParser(Init("p p \"left<func1() \"text\">right\";"));
Statement parsedStatement = statementParser.ParseMarkupStatement();
//Test statement
Assert.AreEqual(typeof(MarkupEmbeddingStatement), parsedStatement.GetType());
//Test MarkupEmbeddingStatement
MarkupEmbeddingStatement markupEmbeddingStatement = (MarkupEmbeddingStatement)parsedStatement;
Assert.AreEqual("p", markupEmbeddingStatement.GetMarkups().Get(0).ToString());
Assert.AreEqual("p", markupEmbeddingStatement.GetMarkups().Get(1).ToString());
//Test embedding
Embedding embedding = markupEmbeddingStatement.GetEmbedding();
Assert.AreEqual("\"left<", embedding.GetPreText().ToString());
Assert.AreEqual(typeof(ExpressionEmbed), embedding.GetEmbed().GetType());
ExpressionEmbed embed = (ExpressionEmbed) embedding.GetEmbed();
Assert.AreEqual(1, embed.GetMarkups().Count);
Assert.AreEqual("func1", embed.GetMarkups().Get(0).ToString());
Assert.AreEqual(typeof(TextExpression), embed.GetExpression().GetType());
Assert.AreEqual("\"text\"", embed.GetExpression().ToString());
Assert.AreEqual(typeof(PostTextTail), embedding.GetTextTail().GetType());
PostTextTail postTextTail = (PostTextTail) embedding.GetTextTail();
Assert.AreEqual(">right\"", postTextTail.GetPostText().ToString());
}
public void ParseMarkupMarkupStatementTest()
{
//Create parser
StatementParser statementParser = new StatementParser(Init("tr td img(src=\"test.png\", width=300);"));
Statement parsedStatement = statementParser.ParseMarkupStatement();
//Test statement
Assert.AreEqual(typeof(MarkupMarkupStatement), parsedStatement.GetType());
//Test MarkupMarkupStatement
MarkupMarkupStatement statement = (MarkupMarkupStatement)parsedStatement;
List<ISyntaxNode>.Enumerator markupEnumerator = statement.GetMarkups().GetEnumerator();
//Test TR
markupEnumerator.MoveNext();
Assert.AreEqual("tr", ((Markup)markupEnumerator.Current).ToString());
//Test TD
markupEnumerator.MoveNext();
Assert.AreEqual("td", ((Markup)markupEnumerator.Current).ToString());
//Test IMG
Assert.AreEqual("img(src=\"test.png\",width=300)", statement.GetMarkup().ToString());
}
public void ParseMarkupStatementTest()
{
//Create parser
StatementParser statementParser = new StatementParser(Init("p();"));
Statement parsedStatement = statementParser.ParseMarkupStatement();
//Test statatement
Assert.AreEqual(typeof(MarkupStatement), parsedStatement.GetType());
//Test MarkupStatement
MarkupStatement statement = (MarkupStatement)parsedStatement;
Assert.AreEqual("p", statement.GetMarkup().GetDesignator().GetIdentifier());
Assert.AreEqual(0, statement.GetMarkup().GetArguments().Count);
}
public void ParseIfStatementTest()
{
//Create parser
StatementParser statementParser = new StatementParser(Init("if (condition1 || condition2) echo \"test\";"));
Statement parsedStatement = statementParser.ParseIfStatement();
//Check IfStatement
Assert.AreEqual(typeof(IfStatement), parsedStatement.GetType());
IfStatement parsedIfStatement = (IfStatement)parsedStatement;
Assert.AreEqual(typeof(OrPredicate), parsedIfStatement.GetPredicate().GetType());
Assert.AreEqual("condition1||condition2", parsedIfStatement.GetPredicate().ToString());
Assert.AreEqual(typeof(EchoExpressionStatement), parsedIfStatement.GetTrueStatement().GetType());
Assert.AreEqual("echo \"test\";", parsedIfStatement.GetTrueStatement().ToString());
}
public void ParseMarkupExpressionStatementTest()
{
//Create parser
StatementParser statementParser = new StatementParser(Init("tr td p \"test\";"));
Statement parsedStatement = statementParser.ParseMarkupStatement();
//Test statement
Assert.AreEqual(typeof(MarkupExpressionStatement), parsedStatement.GetType());
//Test MarkupExpressionStatement
MarkupExpressionStatement statement = (MarkupExpressionStatement)parsedStatement;
Assert.AreEqual(typeof(Markup), statement.GetMarkups().Get(0).GetType());
Assert.AreEqual("tr", statement.GetMarkups().Get(0).ToString());
Assert.AreEqual(typeof(Markup), statement.GetMarkups().Get(1).GetType());
Assert.AreEqual("td", statement.GetMarkups().Get(1).ToString());
Assert.AreEqual(typeof(TextExpression), statement.GetExpression().GetType());
Assert.AreEqual("\"test\"", statement.GetExpression().ToString());
}
public void ParseFuncBindAssingmentTest()
{
//Create parser
StatementParser statementParser = new StatementParser(Init("home(test1, test2) = {}"));
FuncBindAssignment parsedFuncAssignment = statementParser.ParseFuncBindAssignment();
//Test FuncBindAssignment
Assert.AreEqual("home", parsedFuncAssignment.GetIdentifier());
Assert.AreEqual(2, parsedFuncAssignment.GetIdentifiers().Count);
String[] identifierArray = parsedFuncAssignment.GetIdentifiers().ToArray();
Assert.AreEqual("test1", identifierArray[0]);
Assert.AreEqual("test2", identifierArray[1]);
Assert.AreEqual(typeof(BlockStatement), parsedFuncAssignment.GetStatement().GetType());
BlockStatement statement = (BlockStatement) parsedFuncAssignment.GetStatement();
Assert.AreEqual(0, statement.GetStatements().Count);
}
public void ParseEchoExpressionStatementTest()
{
//Create parser
StatementParser statementParser = new StatementParser(Init("echo \"test\";"));
EchoStatement parsedEchoStatement = statementParser.ParseEchoStatement();
//Check echo statement
Assert.AreEqual(typeof(EchoExpressionStatement), parsedEchoStatement.GetType());
Assert.AreEqual("echo \"test\";", parsedEchoStatement.ToString());
}
public void ParseEchoEmbeddingStatementTest()
{
//Create parser
StatementParser statementParser = new StatementParser(Init("echo \"left<func1() \"text\">right\";"));
EchoStatement parsedEchoStatement = statementParser.ParseEchoStatement();
//Check echo statement
Assert.AreEqual(typeof(EchoEmbeddingStatement), parsedEchoStatement.GetType());
Assert.AreEqual("echo \"left<func1\"text\">right\";", parsedEchoStatement.ToString());
}
public FunctionParser(TokenIterator tokenStream)
: base(tokenStream)
{
//Create subparser
statementParser = new StatementParser(tokenStream);
}
public FunctionParser(TokenIterator tokenStream) : base(tokenStream)
{
//Create subparser
statementParser = new StatementParser(tokenStream);
}
