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; }