public void TokenPipeline_MathExpressionException_Thrown_By_Rewriter_Is_Not_Wrapped_In_MathExpressionException()
{
var processor1 = new TestActionProcessor(() => { throw new MathExpressionException("An error."); });
var processor2 = new TestActionProcessor(() => { });
TokenPipeline pipeline = new TokenPipeline(processor1, processor2);
var exception = Assert.Throws<MathExpressionException>(() => pipeline.Process(new TokenStream(new Token[] { }, TokenNotation.Infix)));
Assert.IsNull(exception.InnerException);
Assert.AreEqual("An error.", exception.Message);
}
public void TokenPipeline_Executes_Processors_In_Same_Order_As_Added()
{
DateTime processor1InvokedAt = DateTime.MinValue;
DateTime processor2InvokedAt = DateTime.MinValue;
var processor1 = new TestActionProcessor(() => { processor1InvokedAt = DateTime.Now; Thread.Sleep(5); });
var processor2 = new TestActionProcessor(() => { processor2InvokedAt = DateTime.Now; });
TokenPipeline pipeline = new TokenPipeline(processor1, processor2);
pipeline.Process(new TokenStream(new Token[] { }, TokenNotation.Infix));
Assert.Less(processor1InvokedAt, processor2InvokedAt);
}
public void TokenPipeline_Exceptions_Thrown_By_Processor_Is_Wrapped_In_MathExpressionException()
{
var processor1 = new TestActionProcessor(() => { throw new InvalidOperationException("An error."); });
var processor2 = new TestActionProcessor(() => { });
TokenPipeline pipeline = new TokenPipeline(processor1, processor2);
var exception = Assert.Throws<MathExpressionException>(() => pipeline.Process(new TokenStream(new Token[] { }, TokenNotation.Infix)));
Assert.IsInstanceOf<InvalidOperationException>(exception.InnerException);
Assert.AreEqual("An error occured while processing tokens. See inner exception for details.", exception.Message);
Assert.AreEqual("An error.", exception.InnerException.Message);
}
public void NegationRewriter_Can_Rewrite_Subtraction_Token_If_First_In_Stream()
{
// -3
List<Token> tokens = new List<Token> {
new Token(TokenType.Subtraction, "-"),
new Token(TokenType.Numeric, "3")
};
TokenStream stream = new TokenStream(tokens, TokenNotation.Infix);
TokenPipeline pipeline = new TokenPipeline(new NegationRewriter());
var result = pipeline.Process(stream).ToArray();
Assert.AreEqual(2, result.Length);
Assert.AreEqual(TokenType.Negation, result[0].Type);
}
public void NegationRewriter_Can_Rewrite_Subtraction_Token_If_Preceeded_By_Opening_Parenthesis()
{
// 3+(-2)
List<Token> tokens = new List<Token> {
new Token(TokenType.Numeric, 3),
new Token(TokenType.Addition, "+"),
new Token(TokenType.OpeningParenthesis, "("),
new Token(TokenType.Subtraction, "-"),
new Token(TokenType.Numeric, "3"),
new Token(TokenType.ClosingParenthesis, ")")
};
TokenStream stream = new TokenStream(tokens, TokenNotation.Infix);
TokenPipeline pipeline = new TokenPipeline(new NegationRewriter());
var result = pipeline.Process(stream);
Assert.AreEqual(6, result.Count);
Assert.AreEqual(TokenType.Negation, result[3].Type);
}
public void NegationRewriter_Subtraction_Is_Not_Rewritten()
{
// 3+(-2)
List<Token> tokens = new List<Token> {
new Token(TokenType.Numeric, 3),
new Token(TokenType.Subtraction, "-"),
new Token(TokenType.OpeningParenthesis, "4"),
};
TokenStream stream = new TokenStream(tokens, TokenNotation.Infix);
TokenPipeline pipeline = new TokenPipeline(new NegationRewriter());
var result = pipeline.Process(stream).ToArray();
Assert.AreEqual(3, result.Length);
Assert.AreEqual(TokenType.Subtraction, result[1].Type);
}
public void NegationRewriter_Can_Rewrite_Subtraction_Token_If_Preceeded_By_Operator()
{
// 2+-3
List<Token> tokens = new List<Token> {
new Token(TokenType.Numeric, 2),
new Token(TokenType.Addition, "+"),
new Token(TokenType.Subtraction, "-"),
new Token(TokenType.Numeric, "3")
};
TokenStream stream = new TokenStream(tokens, TokenNotation.Infix);
TokenPipeline pipeline = new TokenPipeline(new NegationRewriter());
var result = pipeline.Process(stream).ToArray();
Assert.AreEqual(4, result.Length);
Assert.AreEqual(TokenType.Negation, result[2].Type);
}