public void FindOperation_StringDoesNotContainStopCharacter_ReturnsEmtpyString()
{
var addition = new AdditionOperator();
var result = addition.FindOperation("no semi-colon");
Assert.AreEqual(string.Empty, result);
}
public void FindOperation_StringStartsWithStopCharacter_ReturnsStringWithStringLength()
{
var addition = new AdditionOperator();
var result = addition.FindOperation(";started with semi-colon");
Assert.AreEqual("sta", result);
}
public void FindOperation_StringShorterThanStringLengthAfterStopCharacter_ReturnsEmptyString()
{
var addition = new AdditionOperator();
var result = addition.FindOperation("JIMMYBUTLER;MJ");
Assert.AreEqual(string.Empty, result);
}
public void FindOperation_StringLongerThanStringLengthAfterStopCharacter_ReturnsStringWithStringLength()
{
var addition = new AdditionOperator();
var result = addition.FindOperation("JACK;SUMMARY;ThisShouldPass");
Assert.AreEqual("SUM", result);
}
public void CalculateOperation_OperatorTextIsCorrect_ReturnStringShowingOperation()
{
var addition = new AdditionOperator();
var result = addition.CalculateOperation(1, 2, "SUM");
Assert.AreEqual(string.Format("{0} + {1} = {2}", 1, 2, 1 + 2), result);
}
public void CalculateOperation_OperatorTextIsNotCorrect_ReturnsEmptyString()
{
var addition = new AdditionOperator();
var result = addition.CalculateOperation(1, 2, "GUM");
Assert.AreEqual(string.Empty, result);
}
public void FindOperation_StringParameterIsEmpty_ReturnsEmptyString()
{
var addition = new AdditionOperator();
var result = addition.FindOperation(string.Empty);
Assert.AreEqual(string.Empty, result);
}
/* ---------- Pending -------- */
public TypeG Visit(AdditionOperator node)
{
//Console.WriteLine("Rock"+ node.ToStringTree());
//Console.WriteLine("TIPOOOO");
VisitChildren(node);
//Console.WriteLine("FIN");
return(TypeG.VOID);
}
public void TestAddition()
{
var op = new AdditionOperator();
var result = op.Apply(1, 2);
Assert.AreEqual(3, result);
}
public void Visit(AdditionOperator op)
{
var leftArgs = VisitChild(op.Left);
var rightArgs = VisitChild(op.Rigth);
_codeStack.Peek().Scope = rightArgs.Scope;
_codeStack.Peek().CodeExpression = new CodeBinaryOperatorExpression(leftArgs.CodeExpression, CodeBinaryOperatorType.Add, rightArgs.CodeExpression);
}
public static void WriteAdditionOperator(Context context, AdditionOperator additionOperator)
{
Write(context, '(');
WriteExpression(context, additionOperator.Left);
Write(context, " + ");
WriteExpression(context, additionOperator.Right);
Write(context, ')');
}
public void WhenAdditionOperatorSetValues_OutputShouldBeCorrect()
{
AdditionOperator addition = new AdditionOperator();
addition.Push(new Value(10m, "TEST"));
addition.Push(new Value(5.5m, "TEST"));
Assert.AreEqual(15.5m, addition.GetValue());
}
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);
}
void ShouldReturnSumOfTwoExpressions()
{
var expression1 = Create <NumberLiteral>();
var expression2 = Create <NumberLiteral>();
var expectedResult = expression1.Result + expression2.Result;
var addition = new AdditionOperator(expression1, expression2);
addition.Result.Should().Be(expectedResult);
}
public void AdditionOperatorAdds()
{
//------------Arrange--------------------
var op = new AdditionOperator();
//------------Act------------------------
var result = op.Eval(2.0, 1.5);
//------------Assert---------------------
Assert.AreEqual(3.5, result);
}
public void WhenAdditionOperatorSetOneValueOneOperator_OutputShouldBeCorrect()
{
AdditionOperator operatorValue = new AdditionOperator();
operatorValue.Push(new Value(10m, "TEST"));
operatorValue.Push(new Value(5.5m, "TEST"));
AdditionOperator output = new AdditionOperator();
output.Push(operatorValue);
output.Push(new Value(4.5m, "TEST"));
Assert.AreEqual(20m, output.GetValue());
}
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 WhenAdditionOperatorSetTwoOperators_OutputShouldBeCorrect()
{
AdditionOperator operator1 = new AdditionOperator();
operator1.Push(new Value(10m, "TEST"));
operator1.Push(new Value(5.5m, "TEST"));
AdditionOperator operator2 = new AdditionOperator();
operator2.Push(new Value(12.2m, "TEST"));
operator2.Push(new Value(4.5m, "TEST"));
AdditionOperator output = new AdditionOperator();
output.Push(operator1);
output.Push(operator2);
Assert.AreEqual(32.2m, output.GetValue());
}
//I dunno how to name this one, deal with it
public void WhenAdditionOperatorSetWithOperatorSourcedOperators_OutputShouldBeCorrect()
{
AdditionOperator level1a_1 = new AdditionOperator();
AdditionOperator level1a_2 = new AdditionOperator();
level1a_1.Push(new Value(14.4m, "TEST"));
level1a_1.Push(new Value(-4.4m, "TEST"));
level1a_2.Push(new Value(15.2m, "TEST"));
level1a_2.Push(new Value(4.8m, "TEST"));
AdditionOperator level1b_1 = new AdditionOperator();
AdditionOperator level1b_2 = new AdditionOperator();
level1b_1.Push(new Value(7.3m, "TEST"));
level1b_1.Push(new Value(2.7m, "TEST"));
level1b_2.Push(new Value(9m, "TEST"));
level1b_2.Push(new Value(1m, "TEST"));
AdditionOperator level2a = new AdditionOperator();
AdditionOperator level2b = new AdditionOperator();
level2a.Push(level1a_1);
level2a.Push(level1a_2);
level2b.Push(level1b_1);
level2b.Push(level1b_2);
AdditionOperator level3 = new AdditionOperator();
level3.Push(level2a);
level3.Push(level2b);
Assert.AreEqual(50, level3.GetValue());
}
public virtual void Visit(AdditionOperator binaryOperator)
{
Visit(binaryOperator.Left);
Visit(binaryOperator.Right);
}
public override void Context()
{
_additionOperator = new AdditionOperator();
}
private static void SetUpFakeAdditionOperator(AdditionOperator fakeOperator)
{
A.CallTo(() => fakeOperator.CalculateSum(A <int> ._, A <int> ._)).ReturnsLazily((int a, int b) => a + b);
}
// Binary operators
public override void Visit(AdditionOperator binaryOperator)
{
Visit(binaryOperator.Left);
Write(" + ");
Visit(binaryOperator.Right);
}
public override void Visit(AdditionOperator binaryOperator)
{
WriteBinaryExpression(binaryOperator, "+");
}
public void Visit(AdditionOperator op, CommonTree tree)
{
Parent(tree).Children.Add(op);
VisitChildren(tree);
}
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})");
}
}
private AddSubOp(AdditionOperator addOp)
{
_isPlusNotMinus = true;
}
