public RequiredTests()
{
_Rules = new ParserProductionRules <TokenType>[]
{
new ParserProductionRules <TokenType>()
{
new RootNode() + Language.SymLet
},
new ParserProductionRules <TokenType>()
{
new RootNode() + Language.SymEqual
},
new ParserProductionRules <TokenType>()
{
new RootNode() + Language.SymLet + Language.SymEqual
},
new ParserProductionRules <TokenType>()
{
new RootNode() + Language.SymLet + Language.SymEqual + Language.SymSemiColon
},
};
_forumalRules = new ParserProductionRules <TokenType>()
{
new RootNode()
+ Language.SymLet
+ Language.VariableName
+ Language.SymEqual
+ Language.Variable
+ Language.SymSemiColon,
Language.Space,
};
}
public ParserBodyTests()
{
// (public | static) class [: subclass]
var modifier = new AnyOrder()
+ Language.SymPublic
+ Language.SymStatic;
var classType = new Choice()
+ modifier
+ Language.SymPublic;
var optionalSubclass = new Optional()
+ Language.SymColon
+ Language.SubclassName;
var body = new Body <TokenType>(Language.SymLeftBrace, Language.SymRightBrace, true);
_rules = new ParserProductionRules <TokenType>()
{
new RootNode()
+ classType
+ Language.SymClass
+ Language.ClassName
+ optionalSubclass + body,
Language.Space
};
}
public AstParserComplexTests()
{
/// {rowset} = SELECT ([refColumnName AS] {columnName}) [(, {columnName})] FROM {rowset} [{joins} WHERE {where clauses}]";
var joinKey = new RootNode("joinKey")
+ (new Optional() + Language.SymLeft)
+ (new Optional() + Language.SymOuter)
+ (new Optional() + Language.SymInner)
+ Language.SymJoin;
var refRowset = new RootNode()
+ Language.RefRowset
+ (new Optional() + Language.RefRowsetAlias);
var join = new Repeat("join")
+ joinKey
+ refRowset
+ Language.SymOn
+ Language.JoinReference
+ Language.SymEqual
+ Language.JoinReference;
var optionalAs = new Optional()
+ Language.ColumnReference
+ Language.SymAs;
var columns = new RootNode()
+ optionalAs
+ Language.ColumnName
+ (new Optional() + (new Repeat() + Language.SymComma + optionalAs + Language.ColumnName));
_rules = new ParserProductionRules <TokenType>()
{
new RootNode("main")
+ (new Optional() + Language.Rowset + Language.SymEqual)
+ Language.SymSelect
+ (new Optional() + Language.SymDistinct)
+ columns
+ Language.SymFrom
+ refRowset
+ (new Optional() + join)
+ Language.SymSemiColon,
Language.Space,
new Bracket <TokenType>(Language.SymLeftParen, Language.SymRightParen)
};
}
public ParserOptionalRepeat()
{
// let {variableName} {variableType} = {variable} [+ {variable}]
var repeatPlusValue = new Optional() + (new Repeat() + Language.SymPlus + Language.Variable);
_onlyPlusRules = new ParserProductionRules <TokenType>()
{
new RootNode()
+ Language.SymLet
+ Language.VariableName
+ Language.VariableType
+ Language.SymEqual
+ Language.Variable
+ repeatPlusValue
+ Language.SymSemiColon,
Language.Space,
};
// let {variableName} {variableType} = {variable} [(+,-,/,*) {variable}]
var opsSign = new Choice()
+ Language.SymPlus
+ Language.SymMinus
+ Language.SymMultiple
+ Language.SymDivide;
var repeatMathValue = new Optional() + (new Repeat() + opsSign + Language.Variable);
_Rules = new ParserProductionRules <TokenType>()
{
new RootNode()
+ Language.SymLet
+ Language.VariableName
+ Language.VariableType
+ Language.SymEqual
+ Language.Variable
+ repeatMathValue
+ Language.SymSemiColon,
Language.Space,
new Bracket <TokenType>(Language.SymLeftParen, Language.SymRightParen),
};
}
public void AstSingleRuleTest()
{
var rowset = new Expression <TokenType>(TokenType.Rowset);
var variable = new Expression <TokenType>(TokenType.Variable);
var equals = new Symbol <TokenType>(TokenType.Equal, "=");
var sstream = new Symbol <TokenType>(TokenType.SStream, "SSTREAM");
var semiColon = new Symbol <TokenType>(TokenType.SemiColon, ";");
var rules = new ParserProductionRules <TokenType>()
{
new RootNode() + rowset + equals + sstream + variable + semiColon,
} +_space;
RootNode tree = new LexicalParser <TokenType>(rules)
.Parse("RdfCountryOrig = SSTREAM @RdfCountrySS;")
?.RootNode;
tree.Should().NotBeNull();
var check = new RootNode
{
new Expression <TokenType>(TokenType.Rowset, "RdfCountryOrig"),
equals,
sstream,
new Expression <TokenType>(TokenType.Variable, "@RdfCountrySS"),
semiColon,
};
tree.Count.Should().Be(check.Count);
var checkList = tree
.Zip(check, (o, i) => new { o, i })
.ToList();
checkList.All(x => x.o.Equals(x.i)).Should().BeTrue();
}
public void AstMultipleRuleTest()
{
var symEqual = new Symbol <TokenType>(TokenType.Equal, "=");
var symSstream = new Symbol <TokenType>(TokenType.SStream, "SSTREAM");
var symReference = new Symbol <TokenType>(TokenType.Reference, "REFERENCE");
var symDeclare = new Symbol <TokenType>(TokenType.Declare, "#DECLARE");
var symSemiColon = new Symbol <TokenType>(TokenType.SemiColon, ";");
var symPlus = new Symbol <TokenType>(TokenType.Plus, "+");
var symUsing = new Symbol <TokenType>(TokenType.Using, "USING");
var rowset = new Expression <TokenType>(TokenType.Rowset);
var variable = new Expression <TokenType>(TokenType.Variable);
var variableType = new Expression <TokenType>(TokenType.VariableType);
var value = new Expression <TokenType>(TokenType.Value);
var rules = new ParserProductionRules <TokenType>()
{
new RootNode()
+ (new Choice()
+ (new RootNode() + rowset + symEqual + symSstream + variable + symSemiColon) // {rowset} = SSTREAM {variable};
+ (new RootNode() + symDeclare + variable + variableType + symEqual + value + symSemiColon) // #DECLARE {variable} int = {value};
+ (new RootNode() + symReference + value + symSemiColon) // REFERENCE {referenceAssembly};
+ (new RootNode() + symUsing + value + symSemiColon) // USING {value};
),
_space,
};
var variations = new[]
{
new {
RawData = "# PoiNamedPlace int = 4444;",
Result = (RootNode)null,
},
new {
RawData = "#DECLARE PoiNamedPlace int = 4444;",
Result = new RootNode {
symDeclare,
new Expression <TokenType>(TokenType.Variable, "PoiNamedPlace"),
new Expression <TokenType>(TokenType.VariableType, "int"),
symEqual,
new Expression <TokenType>(TokenType.Value, "4444"),
symSemiColon,
}
},
new {
RawData = "RdfCountryOrig = SS @RdfCountrySS; ",
Result = (RootNode)null,
},
new {
RawData = "RdfCountryOrig = SSTREAM @RdfCountrySS; ",
Result = new RootNode {
new Expression <TokenType>(TokenType.Rowset, "RdfCountryOrig"),
symEqual,
symSstream,
new Expression <TokenType>(TokenType.Variable, "@RdfCountrySS"),
symSemiColon,
}
},
new {
RawData = "REFERENCE \"System.Data.dll\"",
Result = (RootNode)null,
},
new {
RawData = "REFERENCE \"System.Data.dll\";",
Result = new RootNode {
symReference,
new Expression <TokenType>(TokenType.Value, "\"System.Data.dll\""),
symSemiColon,
}
},
};
int testNumber = -1;
Func <string> why = () => $"TestNumber: {testNumber}";
foreach (var test in variations)
{
testNumber++;
RootNode tree = new LexicalParser <TokenType>(rules)
.Parse(test.RawData)
?.RootNode;
if (test.Result == null)
{
tree.Should().BeNull(why());
continue;
}
tree.Should().NotBeNull(why());
tree.Count.Should().Be(test.Result.Count, why());
var checkList = tree
.Zip(test.Result, (o, i) => new { o, i })
.ToList();
checkList.All(x => x.o.Equals(x.i)).Should().BeTrue(why());
}
}
public void AstOptionalRuleTest()
{
var symEqual = new Symbol <TokenType>(TokenType.Equal, "=");
var symSemiColon = new Symbol <TokenType>(TokenType.SemiColon, ";");
var symSelect = new Symbol <TokenType>(TokenType.Select, "SELECT");
var symAs = new Symbol <TokenType>(TokenType.As, "AS");
var symComma = new Symbol <TokenType>(TokenType.Comma, ",");
var symFrom = new Symbol <TokenType>(TokenType.From, "FROM");
var symWhere = new Symbol <TokenType>(TokenType.Where, "WHERE");
var rowset = new Expression <TokenType>(TokenType.Rowset);
var variable = new Expression <TokenType>(TokenType.Variable);
var referenceColumnName = new Expression <TokenType>(TokenType.ReferenceColumnName);
var columnName = new Expression <TokenType>(TokenType.ColumnName);
var optionalAs = new Optional() + referenceColumnName + symAs;
var repeatColumns = new Repeat() + symComma + optionalAs + columnName;
var rules = new ParserProductionRules <TokenType>()
{
new RootNode() + rowset + symEqual + symSelect + optionalAs + columnName + repeatColumns + symFrom + rowset + symSemiColon,
} +_space;
var variations = new[]
{
new {
RawData = new List <string> {
"a = SELECT FROM;"
},
Result = (RootNode)null,
},
new {
RawData = new List <string> {
"RdfCartoLink =",
" SELECT carto_id.ToString() AS carto_id,",
" link_id,",
" long_haul,",
" coverage_indicator,",
" line_of_control,",
" claimed_by,",
" controlled_by,",
" expanded_inclusion",
" FROM RdfCartoLinkOrig;",
},
Result = new RootNode {
new Expression <TokenType>(TokenType.Rowset, "RdfCartoLink"),
symEqual,
symSelect,
new Expression <TokenType>(TokenType.ReferenceColumnName, "carto_id.ToString()"),
symAs,
new Expression <TokenType>(TokenType.ColumnName, "carto_id"),
symComma,
new Expression <TokenType>(TokenType.ColumnName, "link_id"),
symComma,
new Expression <TokenType>(TokenType.ColumnName, "long_haul"),
symComma,
new Expression <TokenType>(TokenType.ColumnName, "coverage_indicator"),
symComma,
new Expression <TokenType>(TokenType.ColumnName, "line_of_control"),
symComma,
new Expression <TokenType>(TokenType.ColumnName, "claimed_by"),
symComma,
new Expression <TokenType>(TokenType.ColumnName, "controlled_by"),
symComma,
new Expression <TokenType>(TokenType.ColumnName, "expanded_inclusion"),
symFrom,
new Expression <TokenType>(TokenType.Rowset, "RdfCartoLinkOrig"),
symSemiColon,
}
},
new {
RawData = new List <string> {
"RdfLink =",
" SELECT link_id,",
" ref_node_id,",
" nonref_node_id,",
" left_admin_place_id.ToString() AS left_admin_place_id,",
" right_admin_place_id.ToString() AS right_admin_place_id,",
" left_postal_area_id,",
" right_postal_area_id,",
" bridge,",
" tunnel,",
" map_edge_link",
" FROM RdfLinkOrig;",
},
Result = new RootNode {
new Expression <TokenType>(TokenType.Rowset, "RdfLink"),
symEqual,
symSelect,
new Expression <TokenType>(TokenType.ColumnName, "link_id"),
symComma,
new Expression <TokenType>(TokenType.ColumnName, "ref_node_id"),
symComma,
new Expression <TokenType>(TokenType.ColumnName, "nonref_node_id"),
symComma,
new Expression <TokenType>(TokenType.ReferenceColumnName, "left_admin_place_id.ToString()"),
symAs,
new Expression <TokenType>(TokenType.ColumnName, "left_admin_place_id"),
symComma,
new Expression <TokenType>(TokenType.ReferenceColumnName, "right_admin_place_id.ToString()"),
symAs,
new Expression <TokenType>(TokenType.ColumnName, "right_admin_place_id"),
symComma,
new Expression <TokenType>(TokenType.ColumnName, "left_postal_area_id"),
symComma,
new Expression <TokenType>(TokenType.ColumnName, "right_postal_area_id"),
symComma,
new Expression <TokenType>(TokenType.ColumnName, "bridge"),
symComma,
new Expression <TokenType>(TokenType.ColumnName, "tunnel"),
symComma,
new Expression <TokenType>(TokenType.ColumnName, "map_edge_link"),
symFrom,
new Expression <TokenType>(TokenType.Rowset, "RdfLinkOrig"),
symSemiColon,
}
},
};
foreach (var test in variations)
{
RootNode tree = new LexicalParser <TokenType>(rules)
.Parse(string.Join(" ", test.RawData))
?.RootNode;
if (test.Result == null)
{
tree.Should().BeNull();
continue;
}
tree.Count.Should().Be(test.Result.Count);
var checkList = tree
.Zip(test.Result, (o, i) => new { o, i })
.ToList();
checkList.All(x => x.o.Equals(x.i)).Should().BeTrue();
}
}
public void AstRepeatRuleTest()
{
var equal = new Symbol <TokenType>(TokenType.Equal, "=");
var semiColon = new Symbol <TokenType>(TokenType.SemiColon, ";");
var declare = new Symbol <TokenType>(TokenType.Declare, "#DECLARE");
var plus = new Symbol <TokenType>(TokenType.Plus, "+");
var variable = new Expression <TokenType>(TokenType.Variable);
var variableType = new Expression <TokenType>(TokenType.VariableType);
var value = new Expression <TokenType>(TokenType.Value);
var repeatPlusValue = new Optional() + (new Repeat() + plus + value);
var rules = new ParserProductionRules <TokenType>()
{
new RootNode() + declare + variable + variableType + equal + value + repeatPlusValue + semiColon,
} +_space;
var variations = new[]
{
new {
RawData = "#DECLARE EntityTSV string = @@OutputPath@@ + ;",
Result = (RootNode)null,
},
new {
RawData = "#DECLARE EntityTSV string = @@OutputPath@@;",
Result = new RootNode {
declare,
new Expression <TokenType>(TokenType.Variable, "EntityTSV"),
new Expression <TokenType>(TokenType.VariableType, "string"),
equal,
new Expression <TokenType>(TokenType.Value, "@@OutputPath@@"),
semiColon,
}
},
new {
RawData = "#DECLARE EntityTSV string = @@OutputPath@@ + \"Entity.tsv\";",
Result = new RootNode {
declare,
new Expression <TokenType>(TokenType.Variable, "EntityTSV"),
new Expression <TokenType>(TokenType.VariableType, "string"),
equal,
new Expression <TokenType>(TokenType.Value, "@@OutputPath@@"),
plus,
new Expression <TokenType>(TokenType.Value, "\"Entity.tsv\""),
semiColon,
}
},
new {
RawData = "#DECLARE EntityTSV string = @@OutputPath@@ + \"Entity.tsv\" +;",
Result = (RootNode)null,
},
new {
RawData = "#DECLARE EntityTSV string = @@OutputPath@@ + \"Entity.tsv\" + \"/testPath\";",
Result = new RootNode {
declare,
new Expression <TokenType>(TokenType.Variable, "EntityTSV"),
new Expression <TokenType>(TokenType.VariableType, "string"),
equal,
new Expression <TokenType>(TokenType.Value, "@@OutputPath@@"),
plus,
new Expression <TokenType>(TokenType.Value, "\"Entity.tsv\""),
plus,
new Expression <TokenType>(TokenType.Value, "\"/testPath\""),
semiColon,
}
},
};
foreach (var test in variations)
{
RootNode tree = new LexicalParser <TokenType>(rules)
.Parse(test.RawData)
?.RootNode;
if (test.Result == null)
{
tree.Should().BeNull();
continue;
}
tree.Should().NotBeNull(test.RawData);
tree.Count.Should().Be(test.Result.Count);
var checkList = tree
.Zip(test.Result, (o, i) => new { o, i })
.ToList();
checkList.All(x => x.o.Equals(x.i)).Should().BeTrue();
}
}
