public void Parse(string input, string formatted)
{
var n = MathExpressionParser.Parse(input, out var err);
Assert.IsNull(err, $"The expression was expected to be valid, but failed to parse: '{err}'");
Assert.AreEqual(formatted, Format(n));
}
protected override void OnDefineNode()
{
m_RootExpression = MathExpressionParser.Parse(Expression, out m_ExpressionError);
m_Variables.Clear();
if (m_ExpressionError == null)
{
try
{
GetVariables(m_RootExpression);
}
catch (Exception e)
{
m_ExpressionError = e.Message;
}
}
MainOutputPort = this.AddDataOutputPort <float>(null, nameof(MainOutputPort));
}
public void InvalidExpressions(string input)
{
var n = MathExpressionParser.Parse(input, out var err);
Assert.IsNotNull(err, $"The expression was expected to be invalid, but was parsed: '{n}'");
}
public void MathExpressionParser_Can_Parse_And_Evaluate_Variable()
{
var input = this.GetPostfixTokenStream("x");
MathExpressionParser parser = new MathExpressionParser();
MathExpression expression = parser.Parse(input);
MathExpressionContext context = new MathExpressionContext();
context.Define("x", 42);
Assert.AreEqual(42D, expression.Evaluate(context));
}
public void MathExpressionParser_Tokens_Must_Be_In_Postfix_Notation()
{
TokenStream stream = new TokenStream(Enumerable.Empty<Token>(), TokenNotation.Infix);
MathExpressionParser parser = new MathExpressionParser();
var exception = Assert.Throws<MathExpressionException>(() => parser.Parse(stream));
Assert.AreEqual("Tokens are not in postfix notation.", exception.Details);
}
public void MathExpressionParser_TokenStream_With_Invalid_Token_Will_Throw()
{
var tokens = new List<Token>();
tokens.Add(new Token(TokenType.Numeric, 1D));
tokens.Add(new Token(TokenType.Numeric, 2D));
tokens.Add(new Token(TokenType.Unknown, "?"));
TokenStream stream = new TokenStream(tokens, TokenNotation.Postfix);
MathExpressionParser parser = new MathExpressionParser();
var exception = Assert.Throws<MathExpressionException>(() => parser.Parse(stream));
Assert.AreEqual("Expected arithmetic operator in token stream.", exception.Details);
}
public void MathExpressionParser_TokenStream_Must_Be_Provided()
{
MathExpressionParser parser = new MathExpressionParser();
var exception = Assert.Throws<ArgumentNullException>(() => parser.Parse((TokenStream)null));
Assert.AreEqual("tokens", exception.ParamName);
}
public void MathExpressionParser_No_Tokens_In_Stream_Returns_ConstantExpression()
{
TokenStream stream = new TokenStream(Enumerable.Empty<Token>(), TokenNotation.Postfix);
MathExpressionParser parser = new MathExpressionParser();
MathExpression expression = parser.Parse(stream);
Assert.IsNotNull(expression);
Assert.IsInstanceOf<NumericExpression>(expression);
Assert.AreEqual(0D, ((NumericExpression)expression).Value);
}
