public void RequiredSequenceTest(string data, int ruleNumber, bool shouldPass)
{
var parser = new LexicalParser <TokenType>(_Rules[ruleNumber]);
ParserResult result = parser.Parse(data);
result.Should().NotBeNull();
result.IsSuccess.Should().Be(shouldPass);
}
public void LetNodeSingleFailTests(string data)
{
var parser = new LexicalParser <TokenType>(_onlyPlusRules);
ParserResult result = parser.Parse(data);
result.Should().NotBeNull();
result.IsSuccess.Should().BeFalse();
}
public void ForumlaTest(string data, bool shouldPass)
{
var parser = new LexicalParser <TokenType>(_forumalRules);
ParserResult result = parser.Parse(data);
result.Should().NotBeNull();
result.IsSuccess.Should().Be(shouldPass);
}
private void TestParsedEchoVerb <T>(ParserResult <object> result, string input)
where T : EchoVerb
{
result.Should().BeOfType(typeof(Parsed <object>), "the args should have been parsed.");
Parsed <object> parsedResult = (Parsed <object>)result;
parsedResult.Value.Should().BeOfType(typeof(T), $"the args should have been mapped to the {typeof(T).Name} type.");
((T)parsedResult.Value).Input.Should().Be(input);
}
private void TestParsedAddVerb <T>(ParserResult <object> result, int first, int second)
where T : AddVerb
{
result.Should().BeOfType(typeof(Parsed <object>), "the args should have been parsed.");
Parsed <object> parsedResult = (Parsed <object>)result;
parsedResult.Value.Should().BeOfType(typeof(T), $"the args should have been mapped to the {typeof(T).Name} type.");
T addResult = (T)parsedResult.Value;
addResult.First.Should().Be(first);
addResult.Second.Should().Be(second);
}
public void NoClassNameFailTest()
{
IEnumerable <string> data = new List <string>
{
"public class",
"{",
" public static string Cleanse(string name)",
"}",
};
var parser = new LexicalParser <TokenType>(_rules);
ParserResult result = parser.Parse(string.Join(" ", data));
result.Should().NotBeNull();
result.IsSuccess.Should().BeFalse();
}
public void NoStaticTest()
{
IEnumerable <string> data = new List <string>
{
"public class TestClass",
"{",
" public static string Cleanse(string name)",
"}",
};
var parser = new LexicalParser <TokenType>(_rules);
ParserResult result = parser.Parse(string.Join(" ", data));
result.Should().NotBeNull();
result.IsSuccess.Should().BeTrue();
result.RootNode.OfType <Symbol <TokenType> >().Any(x => Language.SymStatic.Equals(x)).Should().BeFalse();
result.RootNode.OfType <Expression <TokenType> >().Single(x => Language.ClassName.Equals(x)).Value.Should().Be("TestClass");
result.RootNode.OfType <Expression <TokenType> >().Any(x => Language.SubclassName.Equals(x)).Should().BeFalse();
}
public void LetDifferentOpsValues(string data, string[] testValues)
{
var parser = new LexicalParser <TokenType>(_Rules);
ParserResult result = parser.Parse(data);
result.Should().NotBeNull();
result.IsSuccess.Should().BeTrue();
result.RootNode.OfType <Expression <TokenType> >().Single(x => Language.VariableName.Equals(x)).Value.Should().Be("MyVariable");
result.RootNode.OfType <Expression <TokenType> >().Single(x => Language.VariableType.Equals(x)).Value.Should().Be("double");
var values = result.RootNode.OfType <Expression <TokenType> >()
.Where(x => Language.Variable.Equals(x));
values.Count().Should().Be(testValues.Length);
values.Select(x => x.Value).OrderBy(x => x)
.Zip(testValues.OrderBy(x => x), (o, i) => new { o, i })
.All(x => x.o == x.i)
.Should().BeTrue();
}
public void LetNodeSingleVariableTest()
{
IEnumerable <string> data = new List <string>
{
"let EmptyLong long? = null;",
};
var parser = new LexicalParser <TokenType>(_onlyPlusRules);
ParserResult result = parser.Parse(string.Join(" ", data));
result.Should().NotBeNull();
result.IsSuccess.Should().BeTrue();
result.RootNode.OfType <Expression <TokenType> >().Single(x => Language.VariableName.Equals(x)).Value.Should().Be("EmptyLong");
result.RootNode.OfType <Expression <TokenType> >().Single(x => Language.VariableType.Equals(x)).Value.Should().Be("long?");
var values = result.RootNode.OfType <Expression <TokenType> >()
.Where(x => Language.Variable.Equals(x));
values.Count().Should().Be(1);
values.First().Value.Should().Be("null");
}
public void FullClassTest()
{
IEnumerable <string> data = new List <string>
{
"public static class NameCleaner",
"{",
" public static string Cleanse(string name)",
" {",
" Dictionary<string, string> changes = new Dictionary<string, string>();",
"",
" changes.Add(\" Twp\", \" Township\");",
" changes.Add(\", Town of\", \"\");",
" changes.Add(\" Town of\", \"\");",
" changes.Add(\", Village of\", \"\");",
"",
" foreach (KeyValuePair<string, string> kvp in changes)",
" {",
" if (true == name.EndsWith(kvp.Key))",
" {",
" name = name.Substring(0, name.Length - kvp.Key.Length) + kvp.Value;",
" }",
" }",
"",
" return name;",
" }",
"}",
};
var parser = new LexicalParser <TokenType>(_rules);
ParserResult result = parser.Parse(string.Join(" ", data));
result.Should().NotBeNull();
result.IsSuccess.Should().BeTrue();
result.RootNode.OfType <Symbol <TokenType> >().Any(x => Language.SymStatic.Equals(x)).Should().BeTrue();
result.RootNode.OfType <Expression <TokenType> >().Single(x => Language.ClassName.Equals(x)).Value.Should().Be("NameCleaner");
result.RootNode.OfType <Expression <TokenType> >().Any(x => Language.SubclassName.Equals(x)).Should().BeFalse();
}
