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 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 ParseSimple()
{
Console.WriteLine("-- ParseSimple ------------------------------------------------");
StatementParser parser = new StatementParser();
StatementCollection statements = parser.Parse("SELECT * FROM dual");
Assert.AreEqual(1, statements.Count);
Console.WriteLine("S1=[" + statements[0] + "]");
statements = parser.Parse("SELECT * FROM dual;");
Assert.AreEqual(1, statements.Count);
Console.WriteLine("S2=[" + statements[0] + "]");
statements = parser.Parse("\nSELECT * FROM dual;\n/\n");
Assert.AreEqual(1, statements.Count);
Console.WriteLine("S3=[" + statements[0] + "]");
statements = parser.Parse("\nSELECT * FROM dual;\nEXIT;\n");
Assert.AreEqual(1, statements.Count);
Console.WriteLine("S4=[" + statements[0] + "]");
statements = parser.Parse("\nSELECT * FROM dual;\n/ SELECT * FROM other ; \n");
Assert.AreEqual(2, statements.Count);
Console.WriteLine("S5=[" + statements[0] + "]");
Console.WriteLine("S5=[" + statements[1] + "]");
}
public void ParseSemiComplex()
{
Console.WriteLine("-- ParseSemiComplex -------------------------------------------");
string sql =
@"CREATE TABLE SEC_DirectoryNode
(
nodeID char(32) NOT NULL,
modVersion int DEFAULT 1 NOT NULL
);
ALTER TABLE SEC_DirectoryNode ADD
(
CONSTRAINT PK_SEC_DirectoryNode PRIMARY KEY (nodeID)
);
CREATE INDEX IX_SEC_DirectoryNode_typeID
ON SEC_DirectoryNode (typeID);";
StatementParser parser = new StatementParser();
StatementCollection statements = parser.Parse(sql);
Assert.AreEqual(3, statements.Count);
foreach (string s in statements)
{
Console.WriteLine("S=[" + s + "]");
}
}
private static TCommand Parse <TCommand>(string s) where TCommand : CommandStatement
{
var cmd = StatementParser.Parse(s);
Assert.IsInstanceOfType(cmd, typeof(TCommand));
return((TCommand)cmd);
}
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 ParseXmlType()
{
Console.WriteLine("-- ParseXmlType -----------------------------------------------");
string sql = @"TEST';' TEST; TEST;";
StatementParser parser = new StatementParser();
parser.IsOptimized = true;
StatementCollection statements = parser.Parse(sql);
Assert.AreEqual(2, statements.Count);
sql =
@"INSERT INTO COR_Field
(fieldID, fieldVersion, name, displayName, shortName, description, remarks, prefixResID,
fieldType, fieldSource, sourceName, definition, valuePaths, processingStage, formulaID,
isStandard, isCataloged, isSearchable, isRetrievable, isLocked, isObsolete)
VALUES
(
'A91A2D673F9846689E2D4AA9B38D81C5',
0,
'BracketGroup',
NULL,
NULL,
NULL,
NULL,
'BracketGroup,Waters.Lib.Resources,UDFResources',
'String',
'Class',
NULL,
xmltype('<definition>
<columnNo>7</columnNo>
<concatSeparator>;</concatSeparator>
</definition>'),
xmltype('<valuePaths>
<namespace prefix=""udf"">urn:www.waters.com/udf</namespace>
<path purpose=""catalog"">/item/catalog/bracketGroup</path>
<path purpose=""default"">quantitationProperties::bracketGroup</path>
<path purpose=""udf"">quantitationProperties::bracketGroup</path>
<path purpose=""xpath"">/udf:result/udf:sample/udf:propertyGroups/udf:quantitationProperties/udf:bracketGroup</path>
</valuePaths>'),
NULL,
'00000000000000000000000000000000',
1,
1,
1,
1,
0,
0
);";
parser = new StatementParser();
parser.IsOptimized = true;
statements = parser.Parse(sql);
Assert.AreEqual(1, statements.Count);
Console.WriteLine("S=[" + statements[0] + "]");
}
public void IntegersAreParsedToAConstExpression()
{
var parser = new StatementParser(new FakeScanner(new[] { new Token("INTEGER", "1", 0, 0, 0) }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(ConstantExpr), result.GetType());
}
public void ParsesSimpleSelectQueryInProcedure()
{
const string query = "create procedure abc\r\n as\r\n begin\r\n select 1;\r\n end";
var parser = new StatementParser(SqlServerVersion.Sql120);
var statements = parser.GetChildStatements(query, false);
Assert.AreEqual(1, statements.Count);
}
public void FloatsAreParsedToAConstExpression()
{
var parser = new StatementParser(new FakeScanner(new[] { new Token("FLOAT", "2.34", 0, 0, 0) }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(ConstantExpr), result.GetType());
}
public void IfThenElseStatementIsBrokenIntoParts()
{
const string query = "create procedure abc\r\n as\r\n if\t \t1 = 1 begin\r\n select 1;\r\n end\r\nelse\r\nselect 99;";
var parser = new StatementParser(SqlServerVersion.Sql120);
var statements = parser.GetChildStatements(query, false);
Assert.IsNotNull(statements.FirstOrDefault(p => p.Text == "select 99;"));
}
public void ParsesSimpleSelectQuery()
{
const string query = "select 1";
var parser = new StatementParser(SqlServerVersion.Sql120);
var statements = parser.GetChildStatements(query, false);
Assert.AreEqual(1, statements.Count);
Assert.AreEqual(query, statements.First().Text);
}
public Batch(StatementParser parser, bool quotedIdentifier, string text, string fileName, string objectName, int objectId)
{
QuotedIdentifier = quotedIdentifier;
Text = text;
FileName = fileName;
ObjectName = objectName;
ObjectId = objectId;
Statements = parser.GetChildStatements(text, quotedIdentifier);
}
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 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 ParseComplexOptimized()
{
Console.WriteLine("-- ParseComplexOptimized --------------------------------------");
string sql =
@"-- ***********************************************************************************************
-- Copyright © 2005 Waters Corporation. All Rights Reserved.
--
-- Everest Security Subsystem Licensing package implementation.
--
-- ***********************************************************************************************
CREATE OR REPLACE PACKAGE BODY SEC_Licensing
AS
-- Forward declaration
PROCEDURE SaveLicense (
p_licenseID IN OUT char,
p_name IN varchar2,
p_license IN xmltype,
p_modifierID IN char,
p_modVersion IN int,
p_newID OUT char
);
-- ===========================================================================================
-- DeleteLicense()
-- ===========================================================================================
PROCEDURE DeleteLicense (
p_licenseID IN char
)
IS
BEGIN
IF (p_licenseID > SystemLicenseID) THEN
BEGIN
DELETE SEC_License
WHERE licenseID = p_licenseID;
END;
END IF;
END DeleteLicense;
END SEC_Licensing;
/";
StatementParser parser = new StatementParser();
parser.IsOptimized = true;
StatementCollection statements = parser.Parse(sql);
Assert.AreEqual(1, statements.Count);
Console.WriteLine("S=[" + statements[0] + "]");
}
internal static IEnumerable <Statement> Parse(this StatementParser parser, string input)
{
using (Scanner scanner = new Scanner(input))
{
scanner.MoveNext();
foreach (var statement in parser.Parse(scanner))
{
yield return(statement);
}
}
}
public void ParseVarBindAssignmentTest()
{
//Create parser
StatementParser statementParser = new StatementParser(Init("var1 = \"test\";"));
VarBindAssignment parsedVarAssignment = statementParser.ParseVarBindAssignment();
//Test VarBindAssignment
Assert.AreEqual("var1", parsedVarAssignment.GetIdentifier());
Assert.AreEqual(typeof(TextExpression), parsedVarAssignment.GetExpression().GetType());
Assert.AreEqual("\"test\"", parsedVarAssignment.GetExpression().ToString());
}
public void ImplementsParse()
{
IParser target = new StatementParser(new FakeScanner(new[] { Token.Empty }));
try
{
Expression actual = target.ParseAll();
Assert.Fail("No tokens to parse");
}
catch (ParseException)
{
}
}
public static IReadOnlyList <YangStatement> ParseStatements(ReadOnlySpan <char> span)
{
var trace = new ParserTrace();
var result = StatementParser.Many(min: 1).Parse(span, trace);
if (!result.Success)
{
throw new FormatException($"error parsing YANG statements at position: {trace.Position}");
}
return(result.Value);
}
void Test(int testNum, string exprToParse, int terminatingChar = -1)
{
++_testsRun;
var testName = string.Format("results-test-{0}.txt", testNum);
using (var tw = File.CreateText(_testDir + testName)) {
string tc = terminatingChar >= 0 ? ((char)terminatingChar).ToString() : "";
tw.WriteLine("------ Test: {0} ------\t{1}\t{2}", testNum, tc, exprToParse.Replace("\n", "\r\n"));
tw.WriteLine();
var utf8Stream = CodePointStream.FromString(exprToParse);
var scanner = new ScanIt(utf8Stream, testName, tw);
var parser = new StatementParser(scanner, new NotMuchOfASymbolTable());
var result = parser.TryParse();
scanner.Message("Parse End");
tw.WriteLine();
result.Dump(tw);
tw.WriteLine();
}
using (var tr = new StreamReader(File.OpenRead(_testDir + testName))) {
var trBytes = tr.ReadToEnd();
System.Console.WriteLine();
System.Console.WriteLine();
System.Console.WriteLine(trBytes);
StreamReader mr = null;
try {
mr = new StreamReader(File.OpenRead(_masterDir + testName));
using ( mr ) {
var mrBytes = mr.ReadToEnd();
int len = mrBytes.Length;
if (len != trBytes.Length)
{
System.Console.WriteLine("Test {0} FAILURE: lengths differ!!!!", testNum);
return;
}
for (int i = 0; i < len; i++)
{
if (trBytes [i] != mrBytes [i])
{
System.Console.WriteLine("Test {0} FAILURE: bytes differ!!!!", testNum);
return;
}
}
}
} catch (System.Exception) {
System.Console.WriteLine("Test {0}: No Master!!!", testNum);
return;
}
}
System.Console.WriteLine("Test {0}: SUCCESS!!", testNum);
++_testsPassed;
}
public void MoreComplexIdentifierExpression()
{
var parser = new StatementParser(new FakeScanner(new[] { Get("a"), Get("+"), Get(1), Get("*"), Get("b"), Get("-"), Get(4) }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(MinusExpr), result.GetType());
var expr = (MinusExpr)result;
Assert.AreEqual(typeof(PlusExpr), expr.Left.GetType());
Assert.AreEqual(typeof(ConstantExpr), expr.Right.GetType());
}
//========================================================================================
// ShowOpenTransactions()
//========================================================================================
/// <summary>
/// Opens a new query window and executes the SELECT FROM v$transaction statement.
/// </summary>
public void ShowOpenTransactions()
{
string formattedSQL =
"SELECT vp.spid as pid, S.blocking_session blocker, S.sid, S.serial#,\n"
+ " s.osuser, S.username, S.machine, S.program,\n"
+ " Q.sql_fulltext as cur_sql, PQ.sql_fulltext as prev_sql,\n"
+ " vt.used_urec, vt.start_date\n"
+ " FROM v$session S\n"
+ " LEFT JOIN v$sqlarea Q on S.sql_id = Q.sql_id\n"
+ " LEFT JOIN v$sqlarea PQ on S.prev_sql_id = PQ.sql_id\n"
+ " LEFT JOIN v$process vp on s.paddr = vp.addr\n"
+ " LEFT JOIN v$transaction vt on s.saddr = vt.ses_addr\n"
+ " ORDER BY S.username, S.machine\n";
InsertText(formattedSQL);
IsSaved = true;
SetTitle();
Logger.WriteLine("QueryWindow.ShowOpenTransactions");
commander.ExecuteControls.IsEnabled = true;
SetStatusMessage(RxExecutingStatus);
resultsView.Clear();
if (splitContainer.Panel2Collapsed)
{
DoToggleResults(null, null);
}
splitContainer.SplitterDistance = (int)(splitContainer.Height * 0.25);
// catch up on Windows messages just to look better
Application.DoEvents();
queries.Clear();
driver.Reset();
var query = new Database.Query(formattedSQL.Replace("\n", String.Empty));
var parser = new StatementParser();
parser.ParseStatement(dbase, query, browser);
queries.Add(query);
// execute query collection
resultsView.Lock();
driver.Execute(queries, basePath, 1);
}
public Parser(string path, string encoding = "utf-8")
{
//use specified encoding to read non latin-1 letters
string text = File.ReadAllText(path, System.Text.Encoding.GetEncoding(encoding));
//change file end of line to CRLF
text = text.Replace("\r\n", "\n").Replace("\r", "\n").Replace("\n", "\r\n");
//add missed - before :20: field if any
text = text.Replace("\r\n:20:", "\r\n-\r\n:20:").Replace("\r\n-\r\n-", "\r\n-");
//save to original file as utf-8 and than read again
File.WriteAllText(path, text, System.Text.Encoding.GetEncoding("utf-8"));
_reader = new StreamReader(path, encoding: System.Text.Encoding.GetEncoding("utf-8"));
_statementParser = new StatementParser(_reader);
}
public void ParseCombine()
{
Console.WriteLine("-- ParseCombine -----------------------------------------------");
StatementParser parser = new StatementParser();
StatementCollection statements = parser.Parse(
"SELECT 'a' FROM dual;\nSELECT 'b' FROM dual;\nSELECT 'c' FROM dual;");
Assert.AreEqual(3, statements.Count);
string combined = statements.Combine();
Console.WriteLine("combined=[" + combined + "]");
}
public void SimpleIdentifier()
{
var parser = new StatementParser(new FakeScanner(new[]
{
Get("b")
}));
var result = parser.ParseAll();
Assert.AreEqual(typeof(IdentifierExpr), result.GetType());
var expr = (IdentifierExpr)result;
Assert.AreEqual("b", expr.Name);
}
private void GetDynamicOrDefaultSql(QueryInfo info)
{
if (info.NamedQuery == null)
{
if (string.IsNullOrEmpty(info.CustomSQL))//从Type获取SQL
{
info.CustomSQL = GetMappedOrDefaultSql(info.GetMappingType());
}
else//已经制定SQL，动态化！
{
StatementParser.ParseDynamicSql(info);
}
}
}
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 WhileStatementIsBrokenIntoParts()
{
const string query = @"create procedure abc
as while 1 = 1 begin
select 1;
end
select 99 ;
select * from a_table;";
var parser = new StatementParser(SqlServerVersion.Sql120);
var statements = parser.GetChildStatements(query, false);
Assert.IsNotNull(statements.FirstOrDefault(p => p.Text == "while 1 = 1"));
}
///获取xml中配置的 User.Select语句， 或者根据对象的属性映射生成语句
private string GetMappedOrDefaultSql(Type type)
{
if (type == null)
{
throw new ArgumentNullException("MappingType", "QueryInfo未指定查询的对象类型!");
}
string key = type.Name + ".Select";
string sql = StatementParser.GetMappedStaticSql(key);
if (sql.Equals(key))
{
sql = (MappingInfo.GetMappingInfo(type).Select + "t");
}
return(sql);
}
public void ParseNotifications()
{
Console.WriteLine("-- ParseNotifications -----------------------------------------");
StatementParser parser = new StatementParser();
parser.ParseNotification += new NotificationEventHandler(parser_ParseNotification);
StatementCollection statements = parser.Parse(
"SELECT 'a' FROM dual;\nSELECT 'b' FROM dual; -- foo\nSELECT 'c' FROM dual;");
Assert.AreEqual(3, statements.Count);
Console.WriteLine("S0=[" + statements[0] + "]");
Console.WriteLine("S1=[" + statements[1] + "]");
Console.WriteLine("S2=[" + statements[2] + "]");
}
public void ParseWrap()
{
Console.WriteLine("-- ParseWrap --------------------------------------------------");
StatementParser parser = new StatementParser();
StatementCollection statements = parser.Parse(
"SELECT 'a' FROM dual;\nSELECT 'b' FROM dual;\nSELECT 'c' FROM dual;");
Assert.AreEqual(3, statements.Count);
string wrapped = statements.Wrap("DefaultSchema");
Assert.AreEqual(3, statements.Parameters.Count);
Console.WriteLine("wrapped=[" + wrapped + "]");
}
static void Main(string[] args)
{
var variableValues = new Dictionary<string, string>
{
{ "VariableA", "Case5" },
{ "VariableB", "CaseX" }
};
var inputTxt = string.Empty;
using (StreamReader reader = new StreamReader("Input.txt"))
{
inputTxt = reader.ReadToEnd();
}
ILanguageTranslator translator = new LanguageTranslator(
new TextReader(inputTxt));
var parser = new StatementParser(translator, variableValues);
parser.Parse();
}
public void IfElseStatementNoBlock()
{
var parser = new StatementParser(new FakeScanner(new[]
{
Get("if"), Get("("), Get(1), Get("!="), Get(3), Get(")"),
Get("a"), Get("="), Get("b"), Get("+"), Get(1), Get(";"),
Get("else"),
Get("c"), Get("="), Get("d"), Get("+"), Get(2), Get(";"),
}));
var result = parser.ParseAll();
Assert.AreEqual(typeof(IfStmt), result.GetType());
var stmt = (IfStmt)result;
Assert.AreEqual(typeof(NotEqualsExpr), stmt.Condition.GetType());
Assert.AreEqual(typeof(AssignmentExpr), stmt.ThenExpression.GetType());
Assert.AreEqual(typeof(AssignmentExpr), stmt.ElseExpression.GetType());
Assert.AreNotSame(stmt.ThenExpression, stmt.ElseExpression);
}
public void LogicalNotTest()
{
var parser = new StatementParser(new FakeScanner(new[] { Get("!"), Get(false) }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(NotExpr), result.GetType());
var expr = (NotExpr)result;
Assert.AreEqual(typeof(ConstantExpr), expr.Right.GetType());
Assert.AreEqual(false, ((ConstantExpr)expr.Right).Value);
}
public void SimpleDivision()
{
var parser = new StatementParser(new FakeScanner(new[] { Get(10), Get("/"), Get(5) }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(DivExpr), result.GetType());
var expr = (DivExpr)result;
Assert.AreEqual(typeof(ConstantExpr), expr.Left.GetType());
Assert.AreEqual(typeof(ConstantExpr), expr.Right.GetType());
Assert.AreEqual(10, ((ConstantExpr)expr.Left).Value);
Assert.AreEqual(5, ((ConstantExpr)expr.Right).Value);
}
public void MultPlusOperatorPrecedence()
{
var parser = new StatementParser(new FakeScanner(new[] { Get(3), Get("*"), Get(2), Get("+"), Get(5) }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(PlusExpr), result.GetType());
}
public void FunctionDefinitionWithParametersTest()
{
var parser = new StatementParser(new FakeScanner(new[]
{
Get("function"), Get("Multiply"), Get("("), Get("a"), Get(":"), Get("int"), Get(","), Get("b"), Get(":"), Get("int"), Get(")"),
Get("{"),
Get("return"), Get("a"), Get("*"), Get("b"), Get(";"),
Get("}")
}));
var result = parser.ParseAll();
Assert.AreEqual(typeof(FunctionDefinitionExpr), result.GetType());
var stmt = (FunctionDefinitionExpr)result;
Assert.AreEqual("Multiply", stmt.Name);
Assert.AreEqual(typeof(ScopeBlockStmt), stmt.Body.GetType());
}
public void FunctionCallWithMultipleParametersTest()
{
var parser = new StatementParser(new FakeScanner(new[]
{
Get("Test"), Get("("), Get(1), Get(","), Get(2), Get(","), Get(3), Get(")"), Get(";"),
}));
var result = parser.ParseAll();
Assert.AreEqual(typeof(FunctionCallExpr), result.GetType());
var stmt = (FunctionCallExpr)result;
Assert.AreEqual("Test", stmt.FunctionName.Name);
Assert.AreEqual(3, stmt.Arguments.Count());
Assert.AreEqual(1, ((ConstantExpr)stmt.Arguments.ElementAt(0)).Value);
Assert.AreEqual(2, ((ConstantExpr)stmt.Arguments.ElementAt(1)).Value);
Assert.AreEqual(3, ((ConstantExpr)stmt.Arguments.ElementAt(2)).Value);
}
public void SimpleParenthesis()
{
var parser = new StatementParser(new FakeScanner(new[] { Get("("), Get(1), Get(")") }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(ConstantExpr), result.GetType());
var expr = (ConstantExpr)result;
Assert.AreEqual(1, expr.Value);
}
public void AndOrPrecedenceTest6()
{
var parser = new StatementParser(new FakeScanner(new[] { Get(true), Get("&&"), Get("("), Get(true), Get("||"), Get(false), Get(")") }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(AndExpr), result.GetType());
}
public void NegationExpressionTest()
{
var parser = new StatementParser(new FakeScanner(new[] { Get("-"), Get(5) }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(NegationExpr), result.GetType());
var expr = (NegationExpr)result;
Assert.AreEqual(typeof(ConstantExpr), expr.Right.GetType());
Assert.AreEqual(5, ((ConstantExpr)expr.Right).Value);
}
public void NestedParenthesisOperatorPrecedence()
{
var parser = new StatementParser(new FakeScanner(new[] { Get("("), Get(2), Get("^"), Get("("), Get(3), Get("*"), Get(4), Get(")"), Get(")") }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(PowExpr), result.GetType());
}
public void SubExpressionInAllPositionsTest()
{
var parser = new StatementParser(new FakeScanner(new[] { Get(true), Get("&&"), Get(false), Get("?"), Get(1234), Get("+"), Get(2345), Get(":"), Get(3), Get("^"), Get(2) }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(ConditionalExpr), result.GetType());
var expr = (ConditionalExpr)result;
Assert.AreEqual(typeof(AndExpr), expr.Condition.GetType());
Assert.AreEqual(typeof(PlusExpr), expr.ThenExpression.GetType());
Assert.AreEqual(typeof(PowExpr), expr.ElseExpression.GetType());
}
public void ConditionalExpressionTest()
{
var parser = new StatementParser(new FakeScanner(new[] { Get(true), Get("?"), Get(1234), Get(":"), Get(5678) }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(ConditionalExpr), result.GetType());
var expr = (ConditionalExpr)result;
Assert.AreEqual(typeof(ConstantExpr), expr.Condition.GetType());
Assert.AreEqual(typeof(ConstantExpr), expr.ThenExpression.GetType());
Assert.AreEqual(typeof(ConstantExpr), expr.ElseExpression.GetType());
Assert.AreEqual(true, ((ConstantExpr)expr.Condition).Value);
Assert.AreEqual(1234, ((ConstantExpr)expr.ThenExpression).Value);
Assert.AreEqual(5678, ((ConstantExpr)expr.ElseExpression).Value);
}
public void LogicalNotPrecedenceTest()
{
var parser = new StatementParser(new FakeScanner(new[] { Get(true), Get("&&"), Get("!"), Get(false) }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(AndExpr), result.GetType());
var expr = (AndExpr)result;
Assert.AreEqual(typeof(ConstantExpr), expr.Left.GetType());
Assert.AreEqual(typeof(NotExpr), expr.Right.GetType());
}
public void IfIfElseStatementNoBlocks()
{
var parser = new StatementParser(new FakeScanner(new[]
{
Get("if"), Get("("), Get(true), Get(")"),
Get("if"), Get("("), Get(false), Get(")"),
Get("a"), Get("="), Get("b"), Get("+"), Get(1), Get(";"),
Get("else"),
Get("c"), Get("="), Get("d"), Get("+"), Get(2), Get(";"),
}));
var result = parser.ParseAll();
Assert.AreEqual(typeof(IfStmt), result.GetType());
var stmt = (IfStmt)result;
Assert.AreEqual(typeof(ConstantExpr), stmt.Condition.GetType());
Assert.AreEqual(true, ((ConstantExpr)stmt.Condition).Value);
Assert.AreEqual(typeof(IfStmt), stmt.ThenExpression.GetType());
Assert.AreEqual(typeof(NoOpStatement), stmt.ElseExpression.GetType());
var innerIf = (IfStmt)stmt.ThenExpression;
Assert.AreEqual(typeof(ConstantExpr), innerIf.Condition.GetType());
Assert.AreEqual(false, ((ConstantExpr)innerIf.Condition).Value);
}
public void FunctionCallTest()
{
var parser = new StatementParser(new FakeScanner(new[]
{
Get("Test"), Get("("), Get(")"), Get(";"),
}));
var result = parser.ParseAll();
Assert.AreEqual(typeof(FunctionCallExpr), result.GetType());
var stmt = (FunctionCallExpr)result;
Assert.AreEqual("Test", stmt.FunctionName.Name);
Assert.AreEqual(0, stmt.Arguments.Count());
}
public void MoreComplexAssignment()
{
var parser = new StatementParser(new FakeScanner(new[] { Get("a"), Get("="), Get("b"), Get("+"), Get(1), Get("*"), Get(5), Get("-"), Get(4) }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(AssignmentExpr), result.GetType());
var expr = (AssignmentExpr)result;
Assert.AreEqual(typeof(IdentifierExpr), expr.Left.GetType());
Assert.AreEqual(typeof(MinusExpr), expr.Right.GetType());
}
public void FunctionCallWithMultipleExpressionParametersTest()
{
var parser = new StatementParser(new FakeScanner(new[]
{
Get("Test"), Get("("), Get(1), Get("+"), Get(2), Get("*"), Get(5), Get(","), Get(1), Get("*"), Get(2), Get(")"), Get(";"),
}));
var result = parser.ParseAll();
Assert.AreEqual(typeof(FunctionCallExpr), result.GetType());
var stmt = (FunctionCallExpr)result;
Assert.AreEqual("Test", stmt.FunctionName.Name);
Assert.AreEqual(2, stmt.Arguments.Count());
Assert.AreEqual(typeof(PlusExpr), stmt.Arguments.ElementAt(0).GetType());
Assert.AreEqual(typeof(MultExpr), stmt.Arguments.ElementAt(1).GetType());
}
public void WhileStatementWithBlock()
{
var parser = new StatementParser(new FakeScanner(new[] { Get("while"), Get("("), Get(1), Get("!="), Get(3), Get(")"), Get("{"), Get("a"), Get("="), Get("b"), Get("+"), Get(1), Get(";"), Get("}") }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(WhileStmt), result.GetType());
var expr = (WhileStmt)result;
Assert.AreEqual(typeof(NotEqualsExpr), expr.Condition.GetType());
Assert.AreEqual(typeof(ScopeBlockStmt), expr.Block.GetType());
var block = (ScopeBlockStmt)expr.Block;
Assert.AreEqual(1, block.Statements.Count());
Assert.AreEqual(typeof(AssignmentExpr), block.Statements.ElementAt(0).GetType());
}
public void PowDivOperatorPrecedence()
{
var parser = new StatementParser(new FakeScanner(new[] { Get(3), Get("^"), Get(2), Get("/"), Get(5) }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(DivExpr), result.GetType());
}
public void WhileStatementSingle()
{
var parser = new StatementParser(new FakeScanner(new[] { Get("while"), Get("("), Get(1), Get("!="), Get(3), Get(")"), Get("a"), Get("="), Get("b"), Get("+"), Get(1), Get(";") }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(WhileStmt), result.GetType());
var expr = (WhileStmt)result;
Assert.AreEqual(typeof(NotEqualsExpr), expr.Condition.GetType());
Assert.AreEqual(typeof(AssignmentExpr), expr.Block.GetType());
}
public void SimplePower()
{
var parser = new StatementParser(new FakeScanner(new[] { Get(3), Get("^"), Get(2) }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(PowExpr), result.GetType());
var expr = (PowExpr)result;
Assert.AreEqual(typeof(ConstantExpr), expr.Left.GetType());
Assert.AreEqual(typeof(ConstantExpr), expr.Right.GetType());
Assert.AreEqual(3, ((ConstantExpr)expr.Left).Value);
Assert.AreEqual(2, ((ConstantExpr)expr.Right).Value);
}
public void WhileStatementWithExpressionBlock()
{
var parser = new StatementParser(new FakeScanner(new[] { Get("while"), Get("("), Get(1), Get("!="), Get(3), Get(")"), Get("{"), Get("b"), Get("+"), Get(1), Get(";"), Get("}") }));
parser.ParseAll();
}
public void BlockStatement()
{
var parser = new StatementParser(new FakeScanner(new[] { Get("{"), Get("a"), Get("="), Get("b"), Get("+"), Get(1), Get(";"), Get("}") }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(ScopeBlockStmt), result.GetType());
}
public void IfStatementWithBlock()
{
var parser = new StatementParser(new FakeScanner(new[]
{
Get("if"), Get("("), Get(1), Get("!="), Get(3), Get(")"),
Get("{"),
Get("a"), Get("="), Get("b"), Get("+"), Get(1), Get(";"),
Get("}")
}));
var result = parser.ParseAll();
Assert.AreEqual(typeof(IfStmt), result.GetType());
var stmt = (IfStmt) result;
Assert.AreEqual(typeof(NotEqualsExpr), stmt.Condition.GetType());
Assert.AreEqual(typeof(ScopeBlockStmt), stmt.ThenExpression.GetType());
Assert.AreEqual(typeof(NoOpStatement), stmt.ElseExpression.GetType());
}
public void DefaultOperatorPrecedenceAsCounterExampleToAbove()
{
var parser = new StatementParser(new FakeScanner(new[] { Get(2), Get("^"), Get(3), Get("*"), Get(4) }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(MultExpr), result.GetType());
}
public void LessThanOrEqualToTest()
{
var parser = new StatementParser(new FakeScanner(new[] { Get(2), Get("<="), Get(3) }));
var result = parser.ParseAll();
Assert.AreEqual(typeof(LessThanOrEqualsExpr), result.GetType());
var expr = (LessThanOrEqualsExpr)result;
Assert.AreEqual(typeof(ConstantExpr), expr.Left.GetType());
Assert.AreEqual(typeof(ConstantExpr), expr.Right.GetType());
Assert.AreEqual(2, ((ConstantExpr)expr.Left).Value);
Assert.AreEqual(3, ((ConstantExpr)expr.Right).Value);
}
