public void TestInterpeterDepth()
{
#if DEBUG
Console.WriteLine("DEBUG");
#else
Console.WriteLine("RELEASE");
#endif
var depth = 500;
var function = "SQRT[Test]";
var input = new StringBuilder();
for (int i = 0; i < depth; i++)
{
input.Append("(");
}
input.Append($"{function})");
for (int i = 0; i < depth - 1; i++)
{
input.Append($"* {function})");
}
var inputStr = input.ToString();
var sw = Stopwatch.StartNew();
var result = CsWrapper.InterpretFormula(inputStr, new MapVariableProvider(new Dictionary <string, double>()
{
{ "Test", 1 }
}), DefaultFunctionProvider.Instance);
sw.Stop();
Console.WriteLine($"Depth: {depth}, Time: {sw.ElapsedMilliseconds}ms");
Assert.AreEqual(1, result);
}
public void TestMixedVariableProvider()
{
var input = new Dictionary <string, string>()
{
{ "A", "[B Test]*C" },
{ "B Test", "C * [D Test]" },
{ "C", "SQRT(E) * 5" }
};
var input2 = new Dictionary <string, double>()
{
{ "D Test", 10.0 },
{ "E", 4.0 }
};
var variableProvider = new CompositeVariableProvider(new Func <IVariableProvider, IVariableProvider>[]
{
x => new ExpressionVariableProvider(input, DefaultFunctionProvider.Instance, x),
x => new MutableVariableProvider(input2)
});
var result = variableProvider.Lookup("A", null);
Assert.AreEqual(1000.0, result);
result = CsWrapper.InterpretFormula("A", variableProvider);
Assert.AreEqual(1000.0, result);
input2["D Test"] = 1.0;
result = CsWrapper.InterpretFormula("A", variableProvider);
Assert.AreEqual(100.0, result);
}
public void TestCompositeFunctionProvider()
{
var input = "MyFunc[] * SQRT[4]";
var result = CsWrapper.InterpretFormula(input, new CompositeFunctionProvider(new [] { new CustomFunctionProvider(), DefaultFunctionProvider.Instance }));
Assert.AreEqual(84, result);
}
public void TestCustomFunctionProvider()
{
var input = "MyFunc[]";
var result = CsWrapper.InterpretFormula(input, new CustomFunctionProvider());
Assert.AreEqual(42, result);
}
public void TestInterpetUsage()
{
var input = "42";
var result = CsWrapper.InterpretFormula(input);
Assert.AreEqual(42, result);
var ast = CsWrapper.ParseFormula(input);
result = CsWrapper.InterpretExpression(ast);
Assert.AreEqual(42, result);
var folded = CsWrapper.ConstantFoldExpression(ast);
result = CsWrapper.InterpretExpression(folded);
Assert.AreEqual(42, result);
}
public void TestAllDataDrivenTestCases()
{
foreach (var sourceFile in Directory.EnumerateFiles(@".\Data", "*.csv"))
{
using (var sr = new StreamReader(sourceFile))
{
using (var csvReader = new CsvReader(sr))
{
var assertions = new List <Tuple <string, double> >();
var expressions = new Dictionary <string, string>();
var dependencyMap = new Dictionary <string, HashSet <string> >();
foreach (var expressionEntry in csvReader.GetRecords <DataDrivenTestCase>())
{
expressions.Add(expressionEntry.Name, expressionEntry.Expression);
assertions.Add(new Tuple <string, double>(expressionEntry.Name, expressionEntry.Expected));
dependencyMap.Add(expressionEntry.Name, CsWrapper.ExtractExpressionDependencies(CsWrapper.ParseFormula(expressionEntry.Expression)));
}
var variableProvider = new ExpressionVariableProvider(expressions, DefaultFunctionProvider.Instance);
foreach (var assertion in assertions)
{
foreach (var dependency in dependencyMap[assertion.Item1])
{
Assert.IsTrue(dependencyMap.ContainsKey(dependency), $"Missing dependency {assertion.Item1}->{dependency}");
}
Assert.AreEqual(assertion.Item2, variableProvider.Lookup(assertion.Item1));
Assert.AreEqual(assertion.Item2, CsWrapper.InterpretFormula(expressions[assertion.Item1], variableProvider));
}
Console.WriteLine($"Validated {assertions.Count} entries from {sourceFile}");
}
}
}
}
