public void Visit(MultiplicationOperator op)
{
op.LeftOperand.Accept(this);
op.RightOperand.Accept(this);
_stack.Push(_stack.Pop() * _stack.Pop());
}
public void Visit(MultiplicationOperator op)
{
op.LeftOperand.Accept(this);
op.RightOperand.Accept(this);
_stack.Push(_stack.Pop() * _stack.Pop());
}
public void Visit(MultiplicationOperator op)
{
op.LeftOperand.Accept(this);
_resultBuilder.Append(" ");
op.RightOperand.Accept(this);
_resultBuilder.Append("*");
}
public void TestPrintIncompleteMultiply()
{
BinaryOperator multiplyOperation = new MultiplicationOperator();
multiplyOperation.SetFirstOperand(new Value(1));
Assert.AreEqual("1 × ".Replace(" ", ""), multiplyOperation.ToString().Replace(" ", ""));
}
public void TestMultiplication()
{
BinaryOperator multiplicationExpression = new MultiplicationOperator();
multiplicationExpression.SetFirstOperand(new Value(1.1M));
multiplicationExpression.SetSecondOperand(new Value(2M));
Assert.AreEqual(2.2M, multiplicationExpression.Evaluate());
}
public void TestPrintMultiplicationExpression()
{
BinaryOperator multiplicationOperation = new MultiplicationOperator();
multiplicationOperation.SetFirstOperand(new Value(2.9M));
multiplicationOperation.SetSecondOperand(new Value(3));
Assert.AreEqual("2.9 × 3".Replace(" ", ""), multiplicationOperation.ToString().Replace(" ", ""));
}
public void TestMultiplication()
{
var op = new MultiplicationOperator();
var result = op.Apply(1, 2);
Assert.AreEqual(2, result);
}
public void Visit(MultiplicationOperator node)
{
VisitBinary(node);
ITerminalWrapper leftWrapper = ReferenceTables.GetValue(node.Left);
ITerminalWrapper rightWrapper = ReferenceTables.GetValue(node.Right);
ReferenceTables.SetValue(node, ((dynamic)leftWrapper) * ((dynamic)rightWrapper));
}
void ShouldReturnProductOfTwoExpressions()
{
var expression1 = Create <NumberLiteral>();
var expression2 = Create <NumberLiteral>();
var expectedResult = expression1.Result * expression2.Result;
var addition = new MultiplicationOperator(expression1, expression2);
addition.Result.Should().Be(expectedResult);
}
public void MultiplicationOperatorMultiplies()
{
//------------Arrange--------------------
var op = new MultiplicationOperator();
//------------Act------------------------
var result = op.Eval(2.0, 1.5);
//------------Assert---------------------
Assert.AreEqual(3.0, result);
}
public void WhenMultiplicationOperatorSetValues_OutputShouldBeCorrect()
{
MultiplicationOperator op = new MultiplicationOperator();
op.Push(new Value(1.55m, "TEST"));
op.Push(new Value(10m, "TEST"));
decimal value = op.GetValue();
Assert.AreEqual(15.5m, value);
}
private void CreateChild(ref AbstractTreeElement node, string expression, ref int curNumber)
{
if (curNumber >= expression.Length)
return;
while (expression[curNumber] == ' ' || expression[curNumber] == ')')
++curNumber;
if (expression[curNumber] == '(')
{
Operator newOpertator;
switch (expression[curNumber + 1])
{
case '+':
newOpertator = new PlusOperator();
break;
case '-':
newOpertator = new MinusOperator();
break;
case '*':
newOpertator = new MultiplicationOperator();
break;
case '/':
newOpertator = new DivisionOperator();
break;
default:
throw new System.Exception();
}
curNumber += 2;
var newNode = newOpertator.LeftChild;
CreateChild(ref newNode, expression, ref curNumber);
newOpertator.LeftChild = newNode;
if (expression[curNumber] == ')')
{
++curNumber;
}
newNode = newOpertator.RightChild;
CreateChild(ref newNode, expression, ref curNumber);
newOpertator.RightChild = newNode;
node = newOpertator;
}
else
{
Operand newOperand = new Operand();
newOperand.Element = 0;
while (expression[curNumber] != ' ')
{
if (expression[curNumber] == ')')
break;
newOperand.Element = newOperand.Element * 10 + (expression[curNumber] - '0');
++curNumber;
}
node = newOperand;
}
}
public void TestPrecedence()
{
var addition = new AdditionOperator();
var subtraction = new SubtractionOperator();
var multiplication = new MultiplicationOperator();
var division = new DivisionOperator();
var negation = new NegationOperator();
Assert.IsTrue(addition.Precedence < multiplication.Precedence);
Assert.IsTrue(addition.Precedence < division.Precedence);
Assert.IsTrue(subtraction.Precedence < multiplication.Precedence);
Assert.IsTrue(subtraction.Precedence < division.Precedence);
Assert.IsTrue(multiplication.Precedence < negation.Precedence);
Assert.IsTrue(division.Precedence < negation.Precedence);
}
public void WhenMultiplicationOperatorSetOneValueOneOperator_OutputShouldBeCorrect()
{
MultiplicationOperator operatorValue = new MultiplicationOperator();
//55m
operatorValue.Push(new Value(10m, "TEST"));
operatorValue.Push(new Value(5.5m, "TEST"));
MultiplicationOperator output = new MultiplicationOperator();
//220
output.Push(operatorValue);
output.Push(new Value(4m, "TEST"));
Assert.AreEqual(220m, output.GetValue());
}
//I dunno how to name this one, deal with it
public void WhenMultiplicationOperatorSetWithOperatorSourcedOperators_OutputShouldBeCorrect()
{
MultiplicationOperator level1a_1 = new MultiplicationOperator();
MultiplicationOperator level1a_2 = new MultiplicationOperator();
//-10
level1a_1.Push(new Value(2.5m, "TEST"));
level1a_1.Push(new Value(-4m, "TEST"));
//38
level1a_2.Push(new Value(15.2m, "TEST"));
level1a_2.Push(new Value(2.5m, "TEST"));
MultiplicationOperator level1b_1 = new MultiplicationOperator();
MultiplicationOperator level1b_2 = new MultiplicationOperator();
//19.71
level1b_1.Push(new Value(7.3m, "TEST"));
level1b_1.Push(new Value(2.7m, "TEST"));
//9
level1b_2.Push(new Value(9m, "TEST"));
level1b_2.Push(new Value(1m, "TEST"));
MultiplicationOperator level2a = new MultiplicationOperator();
MultiplicationOperator level2b = new MultiplicationOperator();
//-380
level2a.Push(level1a_1);
level2a.Push(level1a_2);
//177.39
level2b.Push(level1b_1);
level2b.Push(level1b_2);
MultiplicationOperator level3 = new MultiplicationOperator();
level3.Push(level2a);
level3.Push(level2b);
Assert.AreEqual(-67408.2m, level3.GetValue());
}
public void WhenMultiplicationOperatorSetTwoOperators_OutputShouldBeCorrect()
{
MultiplicationOperator operator1 = new MultiplicationOperator();
//55
operator1.Push(new Value(10m, "TEST"));
operator1.Push(new Value(5.5m, "TEST"));
MultiplicationOperator operator2 = new MultiplicationOperator();
//9
operator2.Push(new Value(2m, "TEST"));
operator2.Push(new Value(4.5m, "TEST"));
MultiplicationOperator output = new MultiplicationOperator();
output.Push(operator1);
output.Push(operator2);
Assert.AreEqual(495m, output.GetValue());
}
public void Visit(MultiplicationOperator op)
{
Visit((BinaryOperator)op);
}
public void Visit(MultiplicationOperator op)
{
FormatBinaryOperator(op, false);
}
public override void Visit(MultiplicationOperator binaryOperator)
{
WriteBinaryExpression(binaryOperator, "*");
}
public override void Visit(MultiplicationOperator binaryOperator)
{
Visit(binaryOperator.Left);
Write(" * ");
Visit(binaryOperator.Right);
}
public void Visit(MultiplicationOperator node)
{
VisitBinary(node);
CheckOperandsAreOfSameType(node);
CheckOperandsRestrictedToTypes(node, new Number().GetType());
}
private void CreateChild(ref AbstractTreeElement node, string expression, ref int curNumber)
{
if (curNumber >= expression.Length)
{
return;
}
while (expression[curNumber] == ' ' || expression[curNumber] == ')')
{
++curNumber;
}
if (expression[curNumber] == '(')
{
Operator newOpertator;
switch (expression[curNumber + 1])
{
case '+':
newOpertator = new PlusOperator();
break;
case '-':
newOpertator = new MinusOperator();
break;
case '*':
newOpertator = new MultiplicationOperator();
break;
case '/':
newOpertator = new DivisionOperator();
break;
default:
throw new System.Exception();
}
curNumber += 2;
var newNode = newOpertator.LeftChild;
CreateChild(ref newNode, expression, ref curNumber);
newOpertator.LeftChild = newNode;
if (expression[curNumber] == ')')
{
++curNumber;
}
newNode = newOpertator.RightChild;
CreateChild(ref newNode, expression, ref curNumber);
newOpertator.RightChild = newNode;
node = newOpertator;
}
else
{
Operand newOperand = new Operand();
newOperand.Element = 0;
while (expression[curNumber] != ' ')
{
if (expression[curNumber] == ')')
{
break;
}
newOperand.Element = newOperand.Element * 10 + (expression[curNumber] - '0');
++curNumber;
}
node = newOperand;
}
}
public virtual void Visit(MultiplicationOperator binaryOperator)
{
Visit(binaryOperator.Left);
Visit(binaryOperator.Right);
}
public void Visit(MultiplicationOperator node)
{
}
public MulDivOp(MultiplicationOperator mulOp)
{
_mulOp = mulOp;
}
