private bool IsEqual(ExpressionNode lhs, ExpressionNode rhs, TypeEnum type, List <object> parameters)
{
bool res = false;
if (type == TypeEnum.Boolean)
{
bool lhsValue = _interpreter.DispatchBoolean(lhs, parameters);
bool rhsValue = _interpreter.DispatchBoolean(rhs, parameters);
res = lhsValue == rhsValue;
}
else if (type == TypeEnum.Real)
{
double lhsValue = _interpreter.DispatchReal(lhs, parameters);
double rhsValue = _interpreter.DispatchReal(rhs, parameters);
res = lhsValue == rhsValue;
}
else if (type == TypeEnum.Integer)
{
int lhsValue = _interpreter.DispatchInt(lhs, parameters);
int rhsValue = _interpreter.DispatchInt(rhs, parameters);
res = lhsValue == rhsValue;
}
else if (type == TypeEnum.Function)
{
Function lhsValue = _interpreter.DispatchFunction(lhs, parameters);
Function rhsValue = _interpreter.DispatchFunction(rhs, parameters);
res = lhsValue.Reference == rhsValue.Reference;
}
else if (type == TypeEnum.Set)
{
Set lhsValue = _interpreter.DispatchSet(lhs, parameters);
Set rhsValue = _interpreter.DispatchSet(rhs, parameters);
res = EquivalentSets(lhsValue, rhsValue);
}
else if (type == TypeEnum.Element)
{
Element lhsValue = _interpreter.DispatchElement(lhs, parameters);
Element rhsValue = _interpreter.DispatchElement(rhs, parameters);
res = lhsValue.Equals(rhsValue);
}
else
{
throw new Exception($"The type '{type}' cannot be used for equivalence");
}
return(res);
}
public void NotEqualBoolean_Function_CorrectValuesReturned(int lhsValue, int rhsValue, bool expected)
{
var lhs = Utilities.GetIntLitExpression();
var rhs = Utilities.GetIntLitExpression();
var expression = new NotEqualExpression(lhs, rhs, 0, 0);
expression.Type = TypeEnum.Function;
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
parent.DispatchFunction(lhs, Arg.Any <List <object> >()).Returns(new Function(lhsValue));
parent.DispatchFunction(rhs, Arg.Any <List <object> >()).Returns(new Function(rhsValue));
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool res = booleanHelper.NotEqualBoolean(expression, new List <object>());
Assert.AreEqual(expected, res);
}
public void NotEqualBoolean_Function_CheckParametersPassedDown()
{
var lhs = Utilities.GetFuncCallExpresssion();
var rhs = Utilities.GetFuncCallExpresssion();
List <object> parameters = Utilities.GetParameterList(4);
List <object> expectedParams = parameters;
var expression = new NotEqualExpression(lhs, rhs, 0, 0);
expression.Type = TypeEnum.Function;
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
List <object> lhsParams = new List <object>();
List <object> rhsParams = new List <object>();
parent.DispatchFunction(lhs, Arg.Do <List <object> >(x => lhsParams = x)).Returns(new Function(0));
parent.DispatchFunction(rhs, Arg.Do <List <object> >(x => rhsParams = x)).Returns(new Function(0));
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
booleanHelper.NotEqualBoolean(expression, parameters);
Assert.AreEqual(expectedParams, lhsParams);
Assert.AreEqual(expectedParams, rhsParams);
}