public void TestPrintIncompleteSubtract()
{
BinaryOperator subtractOperation = new SubtractionOperator();
subtractOperation.SetFirstOperand(new Value(1));
Assert.AreEqual("1 - ".Replace(" ", ""), subtractOperation.ToString().Replace(" ", ""));
}
public void TestSubtraction()
{
var op = new SubtractionOperator();
var result = op.Apply(1, 2);
Assert.AreEqual(-1, result);
}
public void TestPrintSubtractionExpression()
{
BinaryOperator subtractOperation = new SubtractionOperator();
subtractOperation.SetFirstOperand(new Value(2.9M));
subtractOperation.SetSecondOperand(new Value(3));
Assert.AreEqual("2.9 - 3".Replace(" ", ""), subtractOperation.ToString().Replace(" ", ""));
}
public static void WriteSubtractionOperator(Context context, SubtractionOperator subtractionOperator)
{
Write(context, '(');
WriteExpression(context, subtractionOperator.Left);
Write(context, " - ");
WriteExpression(context, subtractionOperator.Right);
Write(context, ')');
}
public void TestSubtraction()
{
BinaryOperator subtractionExpression = new SubtractionOperator();
subtractionExpression.SetFirstOperand(new Value(2.17M));
subtractionExpression.SetSecondOperand(new Value(2.07M));
Assert.AreEqual(0.1M, subtractionExpression.Evaluate());
}
public void WhenSubtractionOperatorSetValues_OutputShouldBeCorrect()
{
SubtractionOperator subtraction = new SubtractionOperator();
subtraction.Push(new Value(10m, "TEST"));
subtraction.Push(new Value(5.5m, "TEST"));
Assert.AreEqual(4.5m, subtraction.GetValue());
}
void ShouldReturnDifferenceOfTwoExpressions()
{
var expression1 = Create <NumberLiteral>();
var expression2 = Create <NumberLiteral>();
var expectedResult = expression1.Result - expression2.Result;
var addition = new SubtractionOperator(expression1, expression2);
addition.Result.Should().Be(expectedResult);
}
public void SetUp()
{
this.additionOperator = A.Fake <AdditionOperator>();
this.subtractionOperator = A.Fake <SubtractionOperator>();
SetUpFakeAdditionOperator(this.additionOperator);
SetUpFakeSubtractionOperator(this.subtractionOperator);
this.testee = new Calculator(this.additionOperator, this.subtractionOperator);
}
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 WhenSubtractionOperatorSetOneValueOneOperator_OutputShouldBeCorrect()
{
SubtractionOperator operatorValue = new SubtractionOperator();
//4.5
operatorValue.Push(new Value(10m, "TEST"));
operatorValue.Push(new Value(5.5m, "TEST"));
SubtractionOperator output = new SubtractionOperator();
output.Push(operatorValue);
output.Push(new Value(4.5m, "TEST"));
decimal value = output.GetValue();
Assert.AreEqual(0m, value);
}
//I dunno how to name this one, deal with it
public void WhenSubtractionOperatorSetWithOperatorSourcedOperators_OutputShouldBeCorrect()
{
SubtractionOperator level1a_1 = new SubtractionOperator();
SubtractionOperator level1a_2 = new SubtractionOperator();
//40
level1a_1.Push(new Value(34.4m, "TEST"));
level1a_1.Push(new Value(-5.6m, "TEST"));
//10.5
level1a_2.Push(new Value(15.2m, "TEST"));
level1a_2.Push(new Value(4.7m, "TEST"));
SubtractionOperator level1b_1 = new SubtractionOperator();
SubtractionOperator level1b_2 = new SubtractionOperator();
//5.5
level1b_1.Push(new Value(7.3m, "TEST"));
level1b_1.Push(new Value(1.8m, "TEST"));
//8
level1b_2.Push(new Value(9m, "TEST"));
level1b_2.Push(new Value(1m, "TEST"));
SubtractionOperator level2a = new SubtractionOperator();
SubtractionOperator level2b = new SubtractionOperator();
//40 - 10.5 = 29.5
level2a.Push(level1a_1);
level2a.Push(level1a_2);
//5.5 - 8 = -2.5
level2b.Push(level1b_1);
level2b.Push(level1b_2);
SubtractionOperator level3 = new SubtractionOperator();
//29.5 - -2.5 = 32
level3.Push(level2a);
level3.Push(level2b);
Assert.AreEqual(32m, level3.GetValue());
}
public void WhenSubtractionOperatorSetTwoOperators_OutputShouldBeCorrect()
{
SubtractionOperator operator1 = new SubtractionOperator();
//4.5
operator1.Push(new Value(10m, "TEST"));
operator1.Push(new Value(5.5m, "TEST"));
SubtractionOperator operator2 = new SubtractionOperator();
//7.5
operator2.Push(new Value(12.2m, "TEST"));
operator2.Push(new Value(4.7m, "TEST"));
SubtractionOperator output = new SubtractionOperator();
output.Push(operator1);
output.Push(operator2);
decimal value = output.GetValue();
Assert.AreEqual(-3m, value);
}
private static ExpTreeNode GetAsExpressionTree(this ParseTreeNode parsedNode, ExpTreeNode parentExpNode)
{
//The current node is a variable / value token. Create a value node and return it back
if (!parsedNode.ChildNodes.Any())
{
switch (parsedNode.Term.Name)
{
case "variable":
{
var varName = parsedNode.FindTokenAndGetValue <string>();
return(new VariableValue(varName, parentExpNode));
}
case "boolean":
return(new LiteralValue(parsedNode.FindTokenAndGetValue <bool>(), parentExpNode));
case "integer":
case "decimal":
return(new LiteralValue(parsedNode.FindTokenAndGetValue <double>(), parentExpNode));
case "SingleQuoteString":
case "DoubleQuoteString":
return(new LiteralValue(parsedNode.FindTokenAndGetValue <string>(), parentExpNode));
default:
throw parsedNode.GetException($"Invalid token type '{parsedNode.Term.Name}' in expression");
}
}
// Look on the next node down
else if (parsedNode.ChildNodes.Count == 1)
{
return(GetAsExpressionTree(parsedNode.ChildNodes[0], parentExpNode));
}
//Ignore parenthesis, the middle non-terminal is what we want
// Look on the next node down
else if (parsedNode.ChildNodes.Count == 3 && parsedNode.ChildNodes[0]?.Token?.Text == "(")
{
return(GetAsExpressionTree(parsedNode.ChildNodes[1], parentExpNode));
}
//Binary operator
else if (parsedNode.ChildNodes.Count == 3)
{
BinaryOperatorBase binaryOp;
var opStr = parsedNode.ChildNodes[1].FindToken().ValueString;
switch (opStr)
{
// Math
case "+":
binaryOp = new AdditionOperator(parentExpNode);
break;
case "-":
binaryOp = new SubtractionOperator(parentExpNode);
break;
case "*":
binaryOp = new MultiplacationOperator(parentExpNode);
break;
case "/":
binaryOp = new DivisionOperator(parentExpNode);
break;
case "%":
binaryOp = new ModulusOperator(parentExpNode);
break;
case "^":
binaryOp = new PowerOperator(parentExpNode);
break;
// Bool
case "~==":
binaryOp = new LooseEqualsOperator(parentExpNode);
break;
case "~!=":
binaryOp = new LooseNotEqualsOperator(parentExpNode);
break;
case "==":
binaryOp = new EqualsOperator(parentExpNode);
break;
case "!=":
binaryOp = new NotEqualsOperator(parentExpNode);
break;
case "like":
binaryOp = new LikeOperator(parentExpNode);
break;
case "match":
binaryOp = new MatchOperator(parentExpNode);
break;
case ">":
binaryOp = new GreaterThanOperator(parentExpNode);
break;
case ">=":
binaryOp = new GreaterThanOrEqualOperator(parentExpNode);
break;
case "<":
binaryOp = new LessThanOperator(parentExpNode);
break;
case "<=":
binaryOp = new LessThanOrEqualOperator(parentExpNode);
break;
case "&&":
binaryOp = new AndOperator(parentExpNode);
break;
case "||":
binaryOp = new OrOperator(parentExpNode);
break;
default:
throw parsedNode.ChildNodes[1].GetException($"Unrecognized operator '{opStr}'");
}
binaryOp.LeftOperand = GetAsExpressionTree(parsedNode.ChildNodes[0], binaryOp);
binaryOp.RightOperand = GetAsExpressionTree(parsedNode.ChildNodes[2], binaryOp);
//Optimize
if (binaryOp.LeftOperand is LiteralValue && binaryOp.RightOperand is LiteralValue)
{
return(new LiteralValue(binaryOp.Eval(), parentExpNode));
}
return(binaryOp);
}
// Unary operator
else if (parsedNode.ChildNodes.Count == 2)
{
var opVal = parsedNode.ChildNodes[0].FindToken().Value;
UnaryOperatorBase unaryOp;
if (parsedNode.ChildNodes[0].FindToken().Value is TypeCode convertType)
{
unaryOp = new TypeConversionOperator(convertType, parentExpNode);
}
else
{
var opStr = opVal.ToString();
switch (opStr)
{
case "!":
unaryOp = new NotOperator(parentExpNode);
break;
//Property Checking
case "lengthof":
unaryOp = new LengthOperator(parentExpNode);
break;
case "typeof":
unaryOp = new TypeOperator(parentExpNode);
break;
default:
unaryOp = new GenericUnaryMathFunctionOperator(opStr, parentExpNode);
break;
}
}
unaryOp.Operand = GetAsExpressionTree(parsedNode.ChildNodes[1], unaryOp);
//Optimize
if (unaryOp.Operand is LiteralValue)
{
return(new LiteralValue(unaryOp.Eval(), parentExpNode));
}
return(unaryOp);
}
else
{
throw parsedNode.GetException($"Invalid number of tokens ({parsedNode.ChildNodes.Count})");
}
}
public virtual void Visit(SubtractionOperator binaryOperator)
{
Visit(binaryOperator.Left);
Visit(binaryOperator.Right);
}
public override void Visit(SubtractionOperator binaryOperator)
{
WriteBinaryExpression(binaryOperator, "-");
}
private AddSubOp(SubtractionOperator subOp)
{
_isPlusNotMinus = false;
}
public override void Visit(SubtractionOperator binaryOperator)
{
Visit(binaryOperator.Left);
Write(" - ");
Visit(binaryOperator.Right);
}
private static void SetUpFakeSubtractionOperator(SubtractionOperator fakeOperator)
{
A.CallTo(() => fakeOperator.CalculateDifference(A <int> ._, A <int> ._)).ReturnsLazily((int a, int b) => a - b);
}
