public void IntExpressionParser_Parse_ValidInputFunctionsTest( string input, string[] variableNames, int[] parameters, int expectedValue) { var factory = new IntExpressionParserFactory(); //Add some non standard functions which will be tested var functions = new[] { new Function <int>("sum", (param) => { return((args) => param[0](args) + param[1](args)); }), new Function <int>("diff", (param) => { return((args) => param[0](args) - param[1](args)); }), new Function <int>("mult", (param) => { return((args) => param[0](args) * param[1](args)); }), new Function <int>("div", (param) => { return((args) => param[0](args) / param[1](args)); }), }; factory.Functions = functions; var expressionParser = factory.Create(variableNames); var handler = expressionParser.Parse(input); int value = handler(parameters); Assert.That(value, Is.EqualTo(expectedValue)); }
public void RuleParser_ParseSourceModule_ExceptionTest(string representation) { var expressionParserFactory = new IntExpressionParserFactory(); var parser = new RuleParser <int>(new ModuleParser <int>(expressionParserFactory), expressionParserFactory); Assert.Throws <ParserException>( () => parser.ParseSourceModule(representation, out var tmp1, out var tmp2)); }
public void RuleParser_ParseSourceModule_ValidInputTest(string representation, string[] expectedParamNames) { var expressionParserFactory = new IntExpressionParserFactory(); var parser = new RuleParser <int>(new ModuleParser <int>(expressionParserFactory), expressionParserFactory); parser.ParseSourceModule(representation, out int id, out var paramNames); Assert.That(paramNames, Is.EqualTo(expectedParamNames)); }
public void RuleParser_ParseContextCondition_ExceptionTest(string sourceModule, string leftContext, string rightContext) { var expressionParserFactory = new IntExpressionParserFactory(); var parser = new RuleParser <int>(new ModuleParser <int>(expressionParserFactory), expressionParserFactory); Assert.Throws <ParserException>( () => parser.ParseContextCondition(sourceModule, leftContext, rightContext)); }
public void RuleParser_ParseSourceModule_UniqueIDTest(string representation1, string representation2) { var expressionParserFactory = new IntExpressionParserFactory(); var parser = new RuleParser <int>(new ModuleParser <int>(expressionParserFactory), expressionParserFactory); parser.ParseSourceModule(representation1, out int id1, out var param1); parser.ParseSourceModule(representation2, out int id2, out var param2); Assert.That(id1, Is.Not.EqualTo(id2)); }
public void IntExpressionParser_Parse_ValidInputTest( string input, string[] variableNames, int[] parameters, int expectedValue) { var expressionParser = new IntExpressionParserFactory().Create(variableNames); var handler = expressionParser.Parse(input); int value = handler(parameters); Assert.That(value, Is.EqualTo(expectedValue)); }
public void RuleParser_ParseParamCondition_ValidInputTest(string input, string[] variableNames, int[] variableValues, bool expectedOutput) { var expressionParserFactory = new IntExpressionParserFactory(); var parser = new RuleParser <int>(new ModuleParser <int>(expressionParserFactory), expressionParserFactory); var intParser = expressionParserFactory.Create(variableNames); var handler = parser.ParseParamCondition(input, intParser); var output = handler(variableValues); Assert.That(output, Is.EqualTo(expectedOutput)); }
public static void TEST() { var expressionParserFactory = new IntExpressionParserFactory(); var generatorParser = new GeneratorParser <int>(expressionParserFactory); var input = "A\n" + "B->BB\n" + "A->BCACA"; var reader = new StringReader(input); var generator = generatorParser.Parse(reader); generator.AdvanceNGenerations(3); var output = generator.CurrentGeneration; }
public void IntExpressionParser_Parse_ExceptionTest(string input, string[] variableNames) { var expressionParser = new IntExpressionParserFactory().Create(variableNames); Assert.Throws <ParserException>(() => expressionParser.Parse(input)); }