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));
}
