public void TestRemoveConstants()
{
var parser = FormulaParser.CreateBuilder()
.ConfigureConstats(constants => constants.Remove("e"))
.Build();
Assert.AreEqual(Math.PI, parser.Evaluate("pi").Value);
Assert.IsFalse(parser.Evaluate("e").Success);
}
public void TestAddFunctionsTwice()
{
var parser = FormulaParser.CreateBuilder()
.ConfigureFunctions(functions =>
{
functions.Add("sum", (a, b) => a + b);
})
.Build();
}
public void TestAddExistingConstant()
{
var parser = FormulaParser.CreateBuilder()
.ConfigureConstats(constants =>
{
constants.Add("pi", Math.PI);
})
.Build();
}
public void TestRemoveFunction()
{
var parser = FormulaParser.CreateBuilder()
.ConfigureFunctions(functions => functions.Remove("min"))
.Build();
Assert.AreEqual(2.0, parser.Evaluate("max(1, 2)").Value);
Assert.IsFalse(parser.Evaluate("min(1, 2)").Success);
}
public void TestRemoveAllConstants()
{
var parser = FormulaParser.CreateBuilder()
.ConfigureConstats(constants =>
{
constants.RemoveAll();
})
.Build();
Assert.IsFalse(parser.Evaluate("pi").Success);
Assert.IsFalse(parser.Evaluate("e").Success);
}
private static void AsserEval(double expectedResult, string formular, IFormulaParser formulaParser, params string[] variables)
{
var variableDict = variables.Select(i => i.Split(':')).ToDictionary(i => i[0], i => double.Parse(i[1]));
var parsers = new IFormulaParser[] { FormulaParser.Create(), FormulaParser.CreateBuilder().Build() };
foreach (var parser in parsers)
{
var result = parser.Evaluate(formular, variableDict);
Assert.IsTrue(result.Success, string.Join("; ", (string)result.Error));
Assert.AreEqual(Math.Round(expectedResult, 5), Math.Round(result.Value, 5));
}
}
public void TestAddFunctionsWithLessThan2Args()
{
var parser = FormulaParser.CreateBuilder()
.ConfigureFunctions(functions =>
{
functions.Add("sum", a => a);
})
.Build();
Assert.AreEqual(3.0, parser.Evaluate("sum(3)"));
Assert.AreEqual(7.0, parser.Evaluate("sum(3, 4)"));
}
public void TestRemoveAllFunctions()
{
var parser = FormulaParser.CreateBuilder()
.ConfigureFunctions(functions =>
{
functions.RemoveAll();
})
.Build();
Assert.IsFalse(parser.Evaluate("min(1, 3.4)").Success);
Assert.IsFalse(parser.Evaluate("abs(2)").Success);
}
public void TestDisableBracket()
{
var parser = FormulaParser
.CreateBuilder()
.ConfigureSupportedFeatures(supportedFeatures =>
{
supportedFeatures.DisableBracket();
})
.Build();
var result = parser.Evaluate("2 * (1 + 2)");
Assert.IsFalse(result.Success);
Assert.AreEqual("column 4: Invalid token '('.", (string)result.Error);
}
public void TestFunctionWithoutParameters()
{
var parser = FormulaParser
.CreateBuilder()
.ConfigureFunctions(functions =>
{
functions.RemoveAll();
functions.Add("get5", () => 5.0);
})
.Build();
Assert.AreEqual(5.0, parser.Evaluate("get5()").Value);
Assert.AreEqual(5.0, parser.Evaluate("get5( )").Value);
}
public void TestDisableScientificNotation()
{
var parser = FormulaParser
.CreateBuilder()
.ConfigureSupportedFeatures(supportedFeatures =>
{
supportedFeatures.DisableScientificNotation();
})
.Build();
var result = parser.Evaluate("2e3");
Assert.IsFalse(result.Success);
Assert.AreEqual("column 0: Invalid token '2e3'.", (string)result.Error);
}
public void Test_ConstantNotExist()
{
var parser = FormulaParser.Create();
var parser2 = FormulaParser.CreateBuilder().ConfigureConstats(c => c.RemoveAll()).Build();
var node = parser.Parse("2 * pi").Value;
parser.Evaluate(node);
Assert.AreEqual(Math.PI * 2, parser.Evaluate(node));
var result = parser2.Evaluate(node);
Assert.IsFalse(result.Success);
Assert.AreEqual("Constant 'pi' does not exist.", (string)result.Error);
}
public void TestAddConstants()
{
var parser = FormulaParser.CreateBuilder()
.ConfigureConstats(constants =>
{
constants.Add("MyPi", Math.PI);
constants.Add("My3", 3);
})
.Build();
Assert.AreEqual(Math.PI, parser.Evaluate("pi").Value);
Assert.AreEqual(Math.E, parser.Evaluate("e").Value);
Assert.AreEqual(Math.PI, parser.Evaluate("MyPi").Value);
Assert.AreEqual(3.0, parser.Evaluate("My3").Value);
}
public void Test_FormulatText()
{
var parser = FormulaParser.Create();
var parser2 = FormulaParser
.CreateBuilder()
.ConfigureFunctions(functions => functions.Add("max", (a, b) => Math.Max(a, b)))
.Build();
parser2.Evaluate("1 + max(2, 4)");
var result = parser.Parse("2 * pi").Value as FormulaNode;
Assert.AreEqual("2 * pi", result.FormulaText);
}
public void Test_VariableNotExist()
{
var parser = FormulaParser.CreateBuilder().ConfigureParsingBehavior(pb => pb.DisableVariableNameValidation()).Build();
var node = parser.Parse("2 * X").Value;
var variables = new Dictionary <string, double>
{
["X"] = 3.0
};
Assert.AreEqual(6.0, parser.Evaluate(node, variables));
var result = parser.Evaluate(node);
Assert.IsFalse(result.Success);
Assert.AreEqual("Variable 'X' does not exist.", (string)result.Error);
}
public void TestNotConfigured_InvalidFunctionIgnoreFunctionValidation()
{
var parser = FormulaParser
.CreateBuilder()
.ConfigureParsingBehavior(parsingBehavior =>
{
parsingBehavior.DisableFunctionNameValidation();
})
.Build();
var result = parser.Parse("1 * TEST()");
Assert.IsTrue(result.Success, string.Join(", ", (string)result.Error));
var functionNames = result.Value.Visit(new CollectFunctionNamesVisitor());
Assert.AreEqual(1, functionNames.Count);
Assert.AreEqual("TEST", functionNames[0]);
}
public void TestDisableVariables()
{
var parser = FormulaParser
.CreateBuilder()
.ConfigureSupportedFeatures(supportedFeatures =>
{
supportedFeatures.DisableVariables();
})
.Build();
var variables = new Dictionary <string, double>
{
["TEST"] = 3.0
};
var result = parser.Evaluate("2 * TEST", variables);
Assert.IsFalse(result.Success);
Assert.AreEqual("column 4: Invalid token 'TEST'.", (string)result.Error);
}
public void TestAddFunction()
{
var parser = FormulaParser.CreateBuilder()
.ConfigureFunctions(functions =>
{
functions.Add("MyFunction0", () => 0);
functions.Add("MyFunction1", a => a);
functions.Add("MyFunction2", (a, b) => a + b);
functions.Add("MyFunction3", (a, b, c) => a + b + c);
functions.Add("MyFunction4", (a, b, c, d) => a + b + c + d);
functions.Add("MyFunction5", (a, b, c, d, e) => a + b + c + d + e);
functions.Add("MyFunctionN", args => args.Aggregate((x, y) => x + y));
})
.Build();
Assert.AreEqual(0.0, parser.Evaluate("MyFunction0()").Value);
Assert.AreEqual(1.0, parser.Evaluate("MyFunction1(1)").Value);
Assert.AreEqual(3.0, parser.Evaluate("MyFunction2(1, 2)").Value);
Assert.AreEqual(6.0, parser.Evaluate("MyFunction3(1, 2, 3)").Value);
Assert.AreEqual(10.0, parser.Evaluate("MyFunction4(1, 2, 3, 4)").Value);
Assert.AreEqual(15.0, parser.Evaluate("MyFunction5(1, 2, 3, 4, 5)").Value);
Assert.AreEqual(55.0, parser.Evaluate("MyFunctionN(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)").Value);
}
public void TestConfigureRegistry()
{
var parser = FormulaParser
.CreateBuilder()
.ConfigureFunctions(functions =>
{
functions.RemoveAll();
functions.Add("sum", args => args.Aggregate((x, y) => x + y));
functions.Add("avg", args => args.Average());
})
.ConfigureConstats(constants =>
{
constants.RemoveAll();
constants.Add("X", 1);
constants.Add("Y", 2);
constants.Add("Z", 3);
})
.Build();
var result = parser.Evaluate("sum(X, Y, Z, 100)");
Assert.IsTrue(result.Success, string.Join(", ", (string)result.Error));
Assert.AreEqual(106.0, result.Value);
}
