public void ConstNodeTest(int value)
{
var node = new ConstNode(value);
var calculatedValue = node.CalculateValue();
calculatedValue.Should().Be(value);
}
public void MultiplicateOperationNodeTest(int left, int right)
{
var leftNode = new ConstNode(left);
var rightNode = new ConstNode(right);
var node = new OperationNode(leftNode, rightNode, (a, b) => a * b);
var calculatedValue = node.CalculateValue();
calculatedValue.Should().Be(left * right);
}
public void DivideOperationNodeTest(int left, int right)
{
var leftNode = new ConstNode(left);
var rightNode = new ConstNode(right);
var node = new OperationNode(leftNode, rightNode, (a, b) => a / b);
var calculatedValue = node.CalculateValue();
calculatedValue.Should().Be((double)left / right);
}
public void LeftNestedExpressionTest(int a, int b, int c)
{
var aNode = new ConstNode(a);
var bNode = new ConstNode(b);
var cNode = new ConstNode(c);
var leftNode = new OperationNode(aNode, bNode, (x, y) => x + y);
var node = new OperationNode(leftNode, cNode, (x, y) => x*y);
var calculatedValue = node.CalculateValue();
calculatedValue.Should().Be((a + b)*c);
}
private IExpressionNode BuildRightNode(IList<string> expressionList, ref int index)
{
var leftValue = int.Parse(expressionList[index]);
var leftNode = new ConstNode(leftValue);
var operationSymbol = expressionList.Count > index + 1 ? expressionList[index + 1] : null;
if (operationSymbol == null || operationSymbol == "+" || operationSymbol == "-")
{
index++;
return leftNode;
}
var operation = _operationSymbol2Function[operationSymbol];
index += 2;
var rightNode = BuildRightNode(expressionList, ref index);
return new OperationNode(leftNode, rightNode, operation);
}
public IExpressionNode BuildExpression(IList<string> expressionList)
{
var leftValue = int.Parse(expressionList[0]);
IExpressionNode leftNode = new ConstNode(leftValue);
var operationSymbol = expressionList.Count > 1 ? expressionList[1] : null;
var index = 2;
while (operationSymbol != null)
{
var rightNode = BuildRightNode(expressionList, ref index);
var operation = _operationSymbol2Function[operationSymbol];
leftNode = new OperationNode(leftNode, rightNode, operation);
operationSymbol = expressionList.Count > index ? expressionList[index] : null;
index++;
}
return leftNode;
}
public void RightLeftNestedExpressionTest(int a, int b, int c, int d)
{
var aNode = new ConstNode(a);
var bNode = new ConstNode(b);
var cNode = new ConstNode(c);
var dNode = new ConstNode(d);
var leftNode = new OperationNode(aNode, bNode, (x, y) => x + y);
var rightNode = new OperationNode(cNode, dNode, (x, y) => x - y);
var node = new OperationNode(leftNode, rightNode, (x, y) => x * y);
var calculatedValue = node.CalculateValue();
calculatedValue.Should().Be((a + b) * (c - d));
}
public void SubstractOperationNodeTest(int left, int right)
{
var leftNode = new ConstNode(left);
var rightNode = new ConstNode(right);
var node = new OperationNode(leftNode, rightNode, (a, b) => a - b);
var calculatedValue = node.CalculateValue();
calculatedValue.Should().Be(left - right);
}