public void EqualBoolean_Element_CheckParametersPassedDown()
{
var lhs = Utilities.GetBoolLitExpression();
var rhs = Utilities.GetBoolLitExpression();
List <object> parameters = Utilities.GetParameterList(4);
List <object> expectedParams = parameters;
var expression = new EqualExpression(lhs, rhs, 0, 0);
expression.Type = TypeEnum.Element;
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
List <object> lhsParams = new List <object>();
List <object> rhsParams = new List <object>();
Element testElement = new Element(17);
parent.DispatchElement(lhs, Arg.Do <List <object> >(x => lhsParams = x)).Returns(testElement);
parent.DispatchElement(rhs, Arg.Do <List <object> >(x => rhsParams = x)).Returns(testElement);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
booleanHelper.EqualBoolean(expression, parameters);
Assert.AreEqual(expectedParams, lhsParams);
Assert.AreEqual(expectedParams, rhsParams);
}
public static BooleanHelper GetBooleanHelper(IInterpreterBoolean interpreter)
{
BooleanHelper booleanHelper = new BooleanHelper();
booleanHelper.SetInterpreter(interpreter);
return(booleanHelper);
}
public void LiteralBoolean_BooleanLiteralExpression_ReturnedCorrectValue(bool value, bool expected)
{
BooleanLiteralExpression e = new BooleanLiteralExpression(value, 0, 0);
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool result = booleanHelper.LiteralBoolean(e);
Assert.AreEqual(expected, result);
}
public void NotBoolean_CorrectValuesReturned(bool input, bool expected)
{
BooleanLiteralExpression child = Utilities.GetBoolLitExpression(input);
var expr = new NotExpression(child, 0, 0);
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
parent.DispatchBoolean(child, Arg.Any <List <object> >()).Returns(input);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool res = booleanHelper.NotBoolean(expr, new List <object>());
Assert.AreEqual(expected, res);
}
public void LessBoolean_Real_CorrectValuesReturned(double lhsValue, double rhsValue, bool expected)
{
var lhs = Utilities.GetRealLitExpression();
var rhs = Utilities.GetRealLitExpression();
var expression = new LessExpression(lhs, rhs, 0, 0);
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
parent.DispatchReal(lhs, Arg.Any <List <object> >()).Returns(lhsValue);
parent.DispatchReal(rhs, Arg.Any <List <object> >()).Returns(rhsValue);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool res = booleanHelper.LessBoolean(expression, new List <object>());
Assert.AreEqual(expected, res);
}
public void AndBoolean__CorrectValuesReturned(bool lhsValue, bool rhsValue, bool expected)
{
BooleanLiteralExpression lhs = new BooleanLiteralExpression(lhsValue, 0, 0);
BooleanLiteralExpression rhs = new BooleanLiteralExpression(rhsValue, 0, 0);
AndExpression andExpr = new AndExpression(lhs, rhs, 0, 0);
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
parent.DispatchBoolean(lhs, Arg.Any <List <object> >()).Returns(lhsValue);
parent.DispatchBoolean(rhs, Arg.Any <List <object> >()).Returns(rhsValue);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool res = booleanHelper.AndBoolean(andExpr, new List <object>());
Assert.AreEqual(expected, res);
}
public void SubsetBoolean_GivenSetAndSet_CorrectValueReturned(int[] a, int[] b, bool expected)
{
Set lhsValue = GetSetWith1DElements(a);
Set rhsValue = GetSetWith1DElements(b);
SetExpression lhs = GetSetInit();
SetExpression rhs = GetSetInit();
SubsetExpression expression = new SubsetExpression(lhs, rhs, 0, 0);
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
DispatchSetForParent(lhsValue, lhs, parent);
DispatchSetForParent(rhsValue, rhs, parent);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool res = booleanHelper.SubsetBoolean(expression, new List <object>());
Assert.AreEqual(expected, res);
}
public void NotEqualBoolean_Bool_CorrectValuesReturned(bool lhsValue, bool rhsValue, bool expected)
{
var lhs = Utilities.GetRealLitExpression();
var rhs = Utilities.GetRealLitExpression();
var expression = new NotEqualExpression(lhs, rhs, 0, 0);
expression.Type = TypeEnum.Boolean;
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
parent.DispatchBoolean(lhs, Arg.Any <List <object> >()).Returns(lhsValue);
parent.DispatchBoolean(rhs, Arg.Any <List <object> >()).Returns(rhsValue);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool res = booleanHelper.NotEqualBoolean(expression, new List <object>());
Assert.AreEqual(expected, res);
}
public void NotBoolean__CheckParametersPassedDown()
{
BooleanLiteralExpression child = Utilities.GetBoolLitExpression();
List <object> parameters = Utilities.GetParameterList(4);
List <object> expectedParams = parameters;
var expression = new NotExpression(child, 0, 0);
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
List <object> lhsParams = new List <object>();
List <object> rhsParams = new List <object>();
parent.DispatchBoolean(child, Arg.Do <List <object> >(x => lhsParams = x));
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
booleanHelper.NotBoolean(expression, parameters);
Assert.AreEqual(expectedParams, lhsParams);
}
public void EqualBoolean_Function_CorrectValuesReturned(int lhsValue, int rhsValue, bool expected)
{
var lhs = Utilities.GetFuncCallExpresssion();
var rhs = Utilities.GetFuncCallExpresssion();
EqualExpression expression = new EqualExpression(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.EqualBoolean(expression, new List <object>());
Assert.AreEqual(expected, res);
}
public void LessBoolean_Real_CheckParametersPassedDown()
{
var lhs = Utilities.GetRealLitExpression();
var rhs = Utilities.GetRealLitExpression();
List <object> parameters = Utilities.GetParameterList(4);
List <object> expectedParams = parameters;
var expression = new LessExpression(lhs, rhs, 0, 0);
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
List <object> lhsParams = new List <object>();
List <object> rhsParams = new List <object>();
parent.DispatchReal(lhs, Arg.Do <List <object> >(x => lhsParams = x));
parent.DispatchReal(rhs, Arg.Do <List <object> >(x => rhsParams = x));
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
booleanHelper.LessBoolean(expression, parameters);
Assert.AreEqual(expectedParams, lhsParams);
Assert.AreEqual(expectedParams, rhsParams);
}
public void EqualBoolean_Set_CorrectValuesReturned(int leftDataRow, int rightDataRow, bool expected)
{
Set lhsValue = GetSet(leftDataRow);
Set rhsValue = GetSet(rightDataRow);
var lhs = Utilities.GetRealLitExpression();
var rhs = Utilities.GetRealLitExpression();
EqualExpression expression = new EqualExpression(lhs, rhs, 0, 0);
expression.Type = TypeEnum.Set;
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
parent.DispatchSet(lhs, Arg.Any <List <object> >()).Returns(lhsValue);
parent.DispatchSet(rhs, Arg.Any <List <object> >()).Returns(rhsValue);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool res = booleanHelper.EqualBoolean(expression, new List <object>());
Assert.AreEqual(expected, res);
}
public void EqualBoolean_Element_CorrectValuesReturned(int[] a, int[] b, bool expected)
{
Element lhsValue = new Element(a.ToList());
Element rhsValue = new Element(b.ToList());
var lhs = Utilities.GetRealLitExpression();
var rhs = Utilities.GetRealLitExpression();
EqualExpression expression = new EqualExpression(lhs, rhs, 0, 0);
expression.Type = TypeEnum.Element;
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
parent.DispatchElement(lhs, Arg.Any <List <object> >()).Returns(lhsValue);
parent.DispatchElement(rhs, Arg.Any <List <object> >()).Returns(rhsValue);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool res = booleanHelper.EqualBoolean(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);
}
private static void DispatchSetForParent(Set setValue, SetExpression setExpression, IInterpreterBoolean parent)
{
parent.DispatchSet(setExpression, Arg.Any <List <object> >()).Returns(setValue);
}
private static void DispatchElementForParent(Element elementValue, ElementExpression elementExpression, IInterpreterBoolean parent)
{
parent.DispatchElement(elementExpression, Arg.Any <List <object> >()).Returns(elementValue);
}
public static BooleanHelper GetBooleanHelper(IInterpreterBoolean interpreter, AST ast)
{
BooleanHelper booleanHelper = GetBooleanHelper(interpreter);
return(booleanHelper);
}
public void SetInterpreter(IInterpreterBoolean interpreter)
{
_interpreter = interpreter;
}
