public void DistinctAddExpressions()
{
var a = new AddExpression(new IntegerExpression(5), new VariableExpression("a"));
var b = new AddExpression(new VariableExpression("a"), new VariableExpression("a"));
Assert.IsFalse(_instance.AreEqual(a, b));
}
public void AddTwoIntegers()
{
AddExpression expr = new AddExpression(new ConstantExpression(1), new ConstantExpression(2));
Assert.AreEqual(3, expr.Evaluate(null));
Assert.IsFalse(expr.HasVariable());
}
public void EqualAddExpressionsMirrored()
{
var a = new AddExpression(new IntegerExpression(5), new VariableExpression("a"));
var b = new AddExpression(new VariableExpression("a"), new IntegerExpression(5));
Assert.IsTrue(_instance.AreEqual(a, b));
}
public AddExpression _CreateAddExpression(BinaryExpressionSyntax node, Expression left, Expression right)
{
// String concatenations require semantic proofs because of the implicit toString() call.
var result = new AddExpression(left, right);
if (!_proofSemantics)
{
return(result);
}
var addSymbol = _semanticModel.GetSymbolInfo(node).Symbol as IMethodSymbol;
if (addSymbol == null)
{
throw new UnsupportedSyntaxException($"failed to resolve the symbol for the add expression {node}");
}
if (!addSymbol.ContainingType.IsStringType())
{
return(result);
}
if (!node.Left.IsEvaluatingToPrimitiveType(_semanticModel) || !node.Right.IsEvaluatingToPrimitiveType(_semanticModel))
{
throw new UnsupportedSyntaxException($"one of the operands of the string concatenation '{node}' will not evaluate to a primitive type");
}
return(result);
}
private IExpression ParseBinaryExpressionLevel1()
{
IExpression expression = this.ParseBinaryExpressionLevel2();
Token token = this.lexer.NextToken();
while (token != null && (token.Value == "+" || token.Value == "-"))
{
switch (token.Value[0])
{
case '+':
expression = new AddExpression(expression, this.ParseBinaryExpressionLevel2());
break;
case '-':
expression = new SubtractExpression(expression, this.ParseBinaryExpressionLevel2());
break;
}
token = this.lexer.NextToken();
}
if (token != null)
{
this.lexer.PushToken(token);
}
return(expression);
}
public void AddIntegerToString()
{
AddExpression expr = new AddExpression(new ConstantExpression(42), new ConstantExpression("1"));
Assert.AreSame(TypeInfo.String, expr.TypeInfo);
Assert.AreEqual("421", expr.Evaluate(null));
}
public void ParseAddMultiplyWithParens()
{
Parser parser = new Parser("(2+3)*4.");
IExpression expression = parser.ParseExpression();
Assert.IsNotNull(expression);
Assert.IsInstanceOfType(expression, typeof(MultiplyExpression));
MultiplyExpression multexpression = (MultiplyExpression)expression;
Assert.IsInstanceOfType(multexpression.RightExpression, typeof(ConstantExpression));
Assert.AreEqual(4, ((ConstantExpression)multexpression.RightExpression).Value);
Assert.IsInstanceOfType(multexpression.LeftExpression, typeof(AddExpression));
AddExpression addexpression = (AddExpression)multexpression.LeftExpression;
Assert.IsInstanceOfType(addexpression.LeftExpression, typeof(ConstantExpression));
Assert.IsInstanceOfType(addexpression.RightExpression, typeof(ConstantExpression));
Assert.AreEqual(2, ((ConstantExpression)addexpression.LeftExpression).Value);
Assert.AreEqual(3, ((ConstantExpression)addexpression.RightExpression).Value);
Assert.IsNull(parser.ParseExpression());
}
private static RawExpression Exp3(char **input)
{
RawExpression e = Exp2(input);
while (true)
{
if (Char(input, '+'))
{
e = new AddExpression
{
Left = e,
Right = Exp2(input),
};
}
else if (Char(input, '-'))
{
e = new SubExpression
{
Left = e,
Right = Exp2(input),
};
}
else
{
break;
}
}
return(e);
}
public void AddIntegerToDouble()
{
AddExpression expr = new AddExpression(new ConstantExpression(1), new ConstantExpression(2.5));
Assert.AreSame(TypeInfo.Double, expr.TypeInfo);
Assert.AreEqual(1 + 2.5, expr.Evaluate(null));
}
public void AddTwoIntegers()
{
AddExpression expr = new AddExpression(new ConstantExpression(1), new ConstantExpression(2));
Assert.AreSame(TypeInfo.Int, expr.TypeInfo);
Assert.AreEqual(3, expr.Evaluate(null));
}
public void AddDoubleToInteger()
{
AddExpression expr = new AddExpression(new ConstantExpression(2.5), new ConstantExpression(1));
Assert.AreSame(TypeInfo.Double, expr.TypeInfo);
Assert.AreEqual(2.5 + 1, expr.Evaluate(null));
}
// Function to perform arithmetic operations.
public Expression applyOp(Expression val1, Expression op, Expression val2)
{
if (((Operator)op).GetOp() == '+')
{
BinaryExpression Add = new AddExpression(val1, val2);
return(Add);
}
else if (((Operator)op).GetOp() == '-')
{
BinaryExpression Substract = new SubstractExpression(val1, val2);
return(Substract);
}
else if (((Operator)op).GetOp() == '*')
{
BinaryExpression Multiply = new MultiplyExpression(val1, val2);
return(Multiply);
}
else if (((Operator)op).GetOp() == '/')
{
BinaryExpression Division = new DivisionExpression(val1, val2);
return(Division);
}
else /*if (((Operator)op).GetOp() == '^')*/
{
BinaryExpression Appointment = new AppointmentExpression(val1, val2);
return(Appointment);
}
}
public static IExpression CreateFromExpression(string expression)
{
IExpression result = null;
if (ConstantExpression.IsMatch(expression))
{
result = new ConstantExpression();
}
else if (AddExpression.IsMatch(expression))
{
result = new AddExpression();
}
else if (SubExpression.IsMatch(expression))
{
result = new SubExpression();
}
else if (MulExpression.IsMatch(expression))
{
result = new MulExpression();
}
else if (DivExpression.IsMatch(expression))
{
result = new DivExpression();
}
else if (LetExpression.IsMatch(expression))
{
result = new LetExpression();
}
else if (VariableExpression.IsMatch(expression))
{
result = new VariableExpression();
}
return(result);
}
public void AddTwoDoubles()
{
AddExpression expr = new AddExpression(new ConstantExpression(2.5), new ConstantExpression(3.7));
Assert.AreSame(TypeInfo.Double, expr.TypeInfo);
Assert.AreEqual(2.5 + 3.7, expr.Evaluate(null));
}
static Expression Generate(Expression par, int lv, ref bool hasVar, Random rand)
{
Expression ret = null;
if (lv == 0)
{
if (!hasVar && rand.NextDouble() > 0.5)
{
ret = new VariableExpression();
hasVar = true;
}
else
{
ret = new ConstantExpression();
while ((ret as ConstantExpression).Value == 0 ||
(ret as ConstantExpression).Value == -1 ||
(ret as ConstantExpression).Value == 1)
{
(ret as ConstantExpression).Value = rand.Next(-10, 10);
}
}
}
else
{
int a = rand.NextDouble() > 0.15 ? lv - 1 : 0;
int b = rand.NextDouble() > 0.15 ? lv - 1 : 0;
switch (rand.Next(0, 3))
{
case 0:
ret = new AddExpression();
(ret as AddExpression).OperandA = Generate(ret, a, ref hasVar, rand);
(ret as AddExpression).OperandB = Generate(ret, b, ref hasVar, rand);
break;
case 1:
ret = new SubExpression();
(ret as SubExpression).OperandA = Generate(ret, a, ref hasVar, rand);
(ret as SubExpression).OperandB = Generate(ret, b, ref hasVar, rand);
break;
case 2:
ret = new NegExpression();
(ret as NegExpression).Value = Generate(ret, a, ref hasVar, rand);
break;
//case 3:
// ret = new MulExpression();
// (ret as MulExpression).OperandA = Generate(ret, a, ref hasVar, rand);
// (ret as MulExpression).OperandB = Generate(ret, b, ref hasVar, rand);
// break;
//case 4:
// ret = new DivExpression();
// (ret as DivExpression).OperandA = Generate(ret, a, ref hasVar, rand);
// (ret as DivExpression).OperandB = Generate(ret, b, ref hasVar, rand);
// break;
}
}
ret.Parent = par;
return(ret);
}
private IExpression ParseBinaryExpression(int level)
{
if (level >= binaryoperators.Length)
{
return(this.ParseTerm());
}
IExpression expr = this.ParseBinaryExpression(level + 1);
if (expr == null)
{
return(null);
}
Token token;
for (token = this.lexer.NextToken(); token != null && this.IsBinaryOperator(level, token); token = this.lexer.NextToken())
{
if (token.Value == "=:=")
{
expr = new StrictEqualExpression(expr, this.ParseBinaryExpression(level + 1));
}
else if (token.Value == "==")
{
expr = new EqualExpression(expr, this.ParseBinaryExpression(level + 1));
}
else if (token.Value == "+")
{
expr = new AddExpression(expr, this.ParseBinaryExpression(level + 1));
}
else if (token.Value == "-")
{
expr = new SubtractExpression(expr, this.ParseBinaryExpression(level + 1));
}
else if (token.Value == "*")
{
expr = new MultiplyExpression(expr, this.ParseBinaryExpression(level + 1));
}
else if (token.Value == "/")
{
expr = new DivideExpression(expr, this.ParseBinaryExpression(level + 1));
}
else if (token.Value == "div")
{
expr = new DivExpression(expr, this.ParseBinaryExpression(level + 1));
}
else if (token.Value == "rem")
{
expr = new RemExpression(expr, this.ParseBinaryExpression(level + 1));
}
}
if (token != null)
{
this.lexer.PushToken(token);
}
return(expr);
}
public void SerializeAddExpression()
{
var num = new LiteralExpression(1);
var a = new AddExpression(num, num);
var b = Reserialize(a);
Assert.AreEqual(a, b);
}
public void AddExpression()
{
var e = new AddExpression(new StringLiteral("wheee"), new Literal("6"));
Assert.IsFalse(e.IsTrivial);
Assert.AreEqual("(\"wheee\"+6)", e.ToString());
Assert.AreEqual("Add", e.Name);
}
public Expression Visit(AddExpression expression)
{
return(_ApplyBinaryExpression(expression,
(left, right) => left + right,
(left, right) => (left.Value == 0) ? right : new AddExpression(left, right),
(left, right) => (right.Value == 0) ? left : new AddExpression(left, right),
(left, right) => new AddExpression(left, right)));
}
public void EvaluateTest(string expression, int expectedResult)
{
var addExpression = new AddExpression();
int result = addExpression.Evaluate(expression);
Assert.That(result, Is.EqualTo(expectedResult));
}
public static void SerializeAddExpression()
{
var v = new NumberLiteral(2);
var a = new AddExpression(v, v);
var b = SerializationUtil.Reserialize(a);
Assert.AreEqual(a, b);
}
public void InstanceIsNotEqualToCompletelyDifferent()
{
var expression1 = new AddExpression(new IntegerExpression(1), new IntegerExpression(2));
var expression2 = new ModuloExpression(new VariableExpression("y"), new VariableExpression("z"));
var available1 = new AvailableExpression(_CreateFlowNode(), expression1);
var available2 = new AvailableExpression(_CreateFlowNode(), expression2);
Assert.AreNotEqual(available1, available2);
}
public void TestEvaluateWithDifferentSizedArrays()
{
var expression = new AddExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)new[] { 1, 2, 3 }),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)new[] { 1 }),
new Context(ExpressiveOptions.None));
Assert.IsNull(expression.Evaluate(null));
}
public void TestEvaluate()
{
var expression = new AddExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)1),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)2),
ExpressiveOptions.None);
Assert.AreEqual(3, expression.Evaluate(null));
}
public void TestStringAddition()
{
var expression = new AddExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)"1"),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)2),
new Context(ExpressiveOptions.None));
Assert.AreEqual("12", expression.Evaluate(null));
}
public void ValidateExpressionTest(string expression, bool expectedResult, string expectedError)
{
var addExpression = new AddExpression();
bool result = addExpression.ValidateExpression(expression, out string error);
Assert.That(result, Is.EqualTo(expectedResult));
Assert.That(error, Is.EqualTo(expectedError));
}
public void TestPlusExpression()
{
IExpressionNode const1 = new ConstantExpression(5);
IExpressionNode const2 = new ConstantExpression(15);
IExpressionNode plusExpr = new AddExpression(const1, const2);
var result = plusExpr.Evaluate();
Assert.AreEqual(20, result);
}
public void InstanceHasNotSameHashCodeAsOtherWithDifferenLeftOperand()
{
var node = _CreateFlowNode();
var expression1 = new AddExpression(new IntegerExpression(3), new VariableExpression("y"));
var expression2 = new AddExpression(new IntegerExpression(5), new VariableExpression("y"));
var available1 = new AvailableExpression(node, expression1);
var available2 = new AvailableExpression(node, expression2);
Assert.AreNotEqual(available1.GetHashCode(), available2.GetHashCode());
}
public void InstanceIsNotEqualToOtherWithOperator()
{
var node = _CreateFlowNode();
var expression1 = new AddExpression(new IntegerExpression(5), new VariableExpression("y"));
var expression2 = new MultiplyExpression(new IntegerExpression(5), new VariableExpression("y"));
var available1 = new AvailableExpression(node, expression1);
var available2 = new AvailableExpression(node, expression2);
Assert.AreNotEqual(available1, available2);
}
public void InstanceIsNotEqualToOtherWithDifferentRightOperand()
{
var node = _CreateFlowNode();
var expression1 = new AddExpression(new VariableExpression("y"), new VariableExpression("y"));
var expression2 = new AddExpression(new VariableExpression("y"), new VariableExpression("z"));
var available1 = new AvailableExpression(node, expression1);
var available2 = new AvailableExpression(node, expression2);
Assert.AreNotEqual(available1, available2);
}
public void Visit(AddExpression x)
{
}
public ISymbolValue Visit(AddExpression x)
{
return E_MathOp(x);
}
IExpression ParseAsmAddExpression(IBlockNode Scope, IStatement Parent)
{
var left = ParseAsmMulExpression(Scope, Parent);
while (laKind == Plus || laKind == Minus)
{
Step();
var e = new AddExpression(t.Kind == Minus);
e.LeftOperand = left;
e.RightOperand = ParseAsmMulExpression(Scope, Parent);
left = e;
}
return left;
}
/// <summary>
/// Note: Add, Multiply as well as Cat Expressions are parsed in this method.
/// </summary>
IExpression AddExpression(IBlockNode Scope = null)
{
var left = UnaryExpression(Scope);
OperatorBasedExpression ae = null;
switch (laKind)
{
case Plus:
case Minus:
ae = new AddExpression(laKind == Minus);
break;
case Tilde:
ae = new CatExpression();
break;
case Times:
case Div:
case Mod:
ae = new MulExpression(laKind);
break;
default:
return left;
}
Step();
ae.LeftOperand = left;
ae.RightOperand = AddExpression(Scope);
return ae;
}
