public void Visit(NotOperator not)
{
not.Right.Accept(this);
var rightOperand = tacs.Last().Result;
tacs.Add(Tac.Not(rightOperand, MakeNewTemp()));
}
public void TrueTest()
{
MockExpression expression = new MockExpression(false);
NotOperator notExpression = new NotOperator(expression);
Assert.IsTrue(notExpression.Evaluate(principal));
}
public void NotOperator_ShouldImplement_ValueEquality()
{
var unaryOperatory = new NotOperator
(
position: 0,
right: new Identifier(0, "right")
);
Assert.That(unaryOperatory.Equals(null), Is.False);
Assert.That(unaryOperatory.Equals(new NegateOperator
(
position: 0,
right: new Identifier(0, "right")
)), Is.False);
Assert.That(unaryOperatory.Equals(new NotOperator
(
position: 0,
right: new Identifier(0, "wrong")
)), Is.False);
Assert.That(unaryOperatory.Equals(new NotOperator
(
position: 0,
right: new Identifier(0, "right")
)), Is.True);
}
public void AndOrNotTestWithQuotedStrings()
{
Parser parser = new Parser();
BooleanExpression expression = parser.Parse(
"(R:\"Human Resources\" OR R:\"General Managers\") AND NOT R:\"HR Specialist\"");
Assert.AreEqual(typeof(AndOperator), expression.GetType());
AndOperator andOperator = (AndOperator)expression;
Assert.AreEqual(typeof(OrOperator), andOperator.Left.GetType());
OrOperator orOperator = (OrOperator)andOperator.Left;
Assert.AreEqual(typeof(RoleExpression), orOperator.Left.GetType());
RoleExpression hrRoleExpression = (RoleExpression)orOperator.Left;
Assert.AreEqual("Human Resources", hrRoleExpression.Word.Value);
Assert.AreEqual(typeof(RoleExpression), orOperator.Right.GetType());
RoleExpression gmRoleExpression = (RoleExpression)orOperator.Right;
Assert.AreEqual("General Managers", gmRoleExpression.Word.Value);
Assert.AreEqual(typeof(NotOperator), andOperator.Right.GetType());
NotOperator notOperator = (NotOperator)andOperator.Right;
Assert.AreEqual(typeof(RoleExpression), notOperator.Expression.GetType());
RoleExpression specialistRoleExpression = (RoleExpression)notOperator.Expression;
Assert.AreEqual("HR Specialist", specialistRoleExpression.Word.Value);
}
public void FalseTest()
{
MockExpression expression = new MockExpression(true);
NotOperator notExpression = new NotOperator(expression);
Assert.IsFalse(notExpression.Evaluate(this.principal));
}
public void Visit(NotOperator node)
{
builder.AppendLine($"Not");
builder.Indent();
node.Right.Accept(this);
builder.Outdent();
}
public void NotOperatorThrows()
{
Operator op = new NotOperator().Not;
MeVariable[] arr = { new MeString("test") };
Assert.IsFalse(op.CanExecute(arr));
TestUtils.CustomExceptionTest(() => op.Execute(arr), typeof(MeContextException));
}
public void ExtractNotOperator()
{
var notOperator = new NotOperator();
CriteriaOperatorExtractor binaryOperatorExtractor = GetBinaryOperatorExtractor(notOperator);
Assert.AreEqual(notOperator, binaryOperatorExtractor.NotOperators[0]);
}
public static LogicalEvaluationStatement CreateNot(NotOperator op, EvaluationStatement operand,
StatementInfo info, IStatement parentStatement = null)
{
return(new LogicalEvaluationStatement(null, op, operand, info)
{
ParentStatement = parentStatement
});
}
internal static ICollection <Tote> GetAllEmptyCarts(IUnitOfWork uow)
{
NotOperator criteria = new NotOperator(new ContainsOperator("Contents", null));
return(Repository
.GetList <Tote>(uow)
.ByCriteria(criteria));
}
public void ExtractContainsNotOperator()
{
var notOperator = new NotOperator();
var containsOperator = new ContainsOperator("", notOperator);
CriteriaOperatorExtractor binaryOperatorExtractor = GetBinaryOperatorExtractor(containsOperator);
Assert.AreEqual(notOperator, binaryOperatorExtractor.NotOperators[0]);
}
public void NotAnonymousTest()
{
Parser parser = new Parser();
BooleanExpression expression = parser.Parse("Not I:?");
NotOperator notOperator = (NotOperator)expression;
IdentityExpression identityExpression = (IdentityExpression)notOperator.Expression;
}
public void NotExpressionTest()
{
Parser parser = new Parser();
BooleanExpression expression = parser.Parse("Not I:Bob");
NotOperator notOperator = (NotOperator)expression;
IdentityExpression identityExpression = (IdentityExpression)notOperator.Expression;
Assert.AreEqual("Bob", identityExpression.Word.Value);
}
public void ExtractContainsNotOperator()
{
var notOperator = new NotOperator();
var containsOperator = new ContainsOperator("", notOperator);
CriteriaOperatorExtractor binaryOperatorExtractor = GetBinaryOperatorExtractor(containsOperator);
Assert.AreEqual(notOperator, binaryOperatorExtractor.NotOperators[0]);
}
public void NotOperatorCanReverse()
{
Operator op = new NotOperator().Not;
MeVariable[] arr = { new MeBoolean(true) };
Assert.IsTrue(op.CanExecute(arr));
bool result = op.Execute(arr).Get <bool>();
Assert.AreEqual(false, result);
}
internal static ICollection <MaterialWarehouseItem> GetIssuableItemsByPart(Part part)
{
var op1 = new BinaryOperator("Part", part);
var op2 = new NotOperator(new NullOperator("RackLocation"));
var op3 = new BinaryOperator("Qty", 0, BinaryOperatorType.Greater);
var criteria = new GroupOperator(op1, op2, op3);
return(Repository
.GetList <MaterialWarehouseItem>(part.Session)
.ByCriteria(criteria));
}
public void ExtractGroupedNotOperator()
{
var notOperator1 = new NotOperator();
var notOperator2 = new NotOperator();
var groupOperator = new GroupOperator(notOperator2, notOperator1);
CriteriaOperatorExtractor binaryOperatorExtractor = GetBinaryOperatorExtractor(groupOperator);
Assert.AreEqual(notOperator1, binaryOperatorExtractor.NotOperators[0]);
Assert.AreEqual(notOperator1, binaryOperatorExtractor.NotOperators[1]);
}
public void ExtractGroupedNotOperator()
{
var notOperator1 = new NotOperator();
var notOperator2 = new NotOperator();
var groupOperator = new GroupOperator(notOperator2, notOperator1);
CriteriaOperatorExtractor binaryOperatorExtractor = GetBinaryOperatorExtractor(groupOperator);
Assert.AreEqual(notOperator1, binaryOperatorExtractor.NotOperators[0]);
Assert.AreEqual(notOperator1, binaryOperatorExtractor.NotOperators[1]);
}
public static bool IsUniqueConstrauntViolated <T>(this T prmValue, params string[] prmUniqueFields) where T : XPObject
{
var operands = new CriteriaOperatorCollection();
Array.ForEach(prmUniqueFields, property => operands.Add(new BinaryOperator(new OperandProperty(property),
new OperandValue(prmValue.ClassInfo.GetMember(property).GetValue(prmValue)), BinaryOperatorType.Equal)));
CriteriaOperator keyCondition = new NotOperator(new BinaryOperator(prmValue.ClassInfo.KeyProperty.Name,
prmValue.ClassInfo.KeyProperty.GetValue(prmValue)));
return(prmValue.Session.FindObject <T>(PersistentCriteriaEvaluationBehavior.InTransaction,
new GroupOperator(new GroupOperator(GroupOperatorType.And, operands), keyCondition)) != null);
}
public void ReplaceNestedOperator()
{
var unaryOperator = new UnaryOperator(UnaryOperatorType.BitwiseNot, "pro");
CriteriaOperator criteriaOperator = new GroupOperator(new BinaryOperator(), unaryOperator);
var binaryOperatorExtractor = new CriteriaOperatorExtractor();
var notOperator = new NotOperator();
binaryOperatorExtractor.Replace(ref criteriaOperator, unaryOperator.ToString(), notOperator);
Assert.AreEqual(((GroupOperator)criteriaOperator).Operands[1], notOperator);
}
public void NotAnonymousTest()
{
Parser parser = new Parser();
BooleanExpression expression = parser.Parse("Not I:?");
Assert.AreEqual(typeof(NotOperator), expression.GetType());
NotOperator notOperator = (NotOperator)expression;
Assert.AreEqual(typeof(IdentityExpression), notOperator.Expression.GetType());
IdentityExpression identityExpression = (IdentityExpression)notOperator.Expression;
Assert.AreEqual(typeof(AnonymousExpression), identityExpression.Word.GetType());
}
public void NotOperator_ShouldPrint()
{
var ast = new NotOperator
(
position: 0,
right: new Identifier(0, "y")
);
Assert.That(PrettyPrinter.ToString(ast), Is.EqualTo(
@"Not
Identifier(y)
"));
}
public void Interpret_ExpressionIsUnknown_ThrowsArgumentException()
{
//Arrange
var interpreter = new QueryFilterInterpreter();
var expression = new NotOperator()
{
Operand = new UnknownCondition()
};
//Act
//Assert
interpreter.Interpret(expression, Expression.Parameter(typeof(string)));
}
public void Interpret_ExpressionIsUnknown_ThrowsArgumentException()
{
//Arrange
var interpreter = new QueryFilterInterpreter();
var expression = new NotOperator()
{
Operand = new UnknownCondition()
};
//Act
//Assert
interpreter.Interpret(expression, Expression.Parameter(typeof(string)));
}
public void AndNotTest()
{
Parser parser = new Parser();
BooleanExpression expression = parser.Parse("R:Managers AND NOT I:Bob");
AndOperator andOperator = (AndOperator)expression;
RoleExpression roleExpression = (RoleExpression)andOperator.Left;
Assert.AreEqual("Managers", roleExpression.Word.Value);
NotOperator notOperator = (NotOperator)andOperator.Right;
IdentityExpression identityExpression = (IdentityExpression)notOperator.Expression;
Assert.AreEqual("Bob", identityExpression.Word.Value);
}
/* Methods */
private void Tokenize()
{
tokens = new List<Token>();
Token prev = null;
Token t = null;
while (_inputReader.Peek() != -1)
{
char c = (char)_inputReader.Read();
switch (c)
{
case Token.AND:
t = new AndOperator();
tokens.Add(t);
break;
case Token.OR:
t = new OrOperator();
tokens.Add(t);
break;
case Token.LEFT_PAREN:
// Insert implicit AND operators before (
if ((prev is RightParenthesis) || (prev is Literal) || (prev is NotOperator))
tokens.Add(new AndOperator());
t = new LeftParenthesis();
tokens.Add(t);
break;
case Token.RIGHT_PAREN:
t = new RightParenthesis();
tokens.Add(t);
break;
case Token.NOT:
t = new NotOperator();
tokens.Add(t);
break;
default:
t = new Literal(c);
// Insert implicit AND operators before Literals
if ((prev is RightParenthesis) || (prev is Literal) || (prev is NotOperator))
tokens.Add(new AndOperator());
tokens.Add(t);
break;
}
prev = t;
}
}
public void BuildSupplyPoint()
{
MarketDB.Instance.InsertByForce();
datalayer = PolicyDL.Instance;
UsernameEqualsLeaf2 = new UsernameEquals(PolicyType.Global, "bla", "bla_bla", 1);
UsernameEqualsLeaf = new UsernameEquals(PolicyType.Global, "bla", "bla_bla", 2);
QuantityLessThanLeaf = new QuantityLessThan(PolicyType.Global, "bla", "bla_bla", 3);
QuantityGreaterThanLeaf = new QuantityGreaterThan(PolicyType.Global, "bla", "bla_bla", 4);
PriceLessThanLeaf = new PriceLessThan(PolicyType.Global, "bla", "bla_bla", 5);
PriceGreaterThanLeaf = new PriceGreaterThan(PolicyType.Global, "bla", "bla_bla", 6);
AddressEqualsLeaf = new AddressEquals(PolicyType.Global, "bla", "bla_bla", 7);
AndHas0opSun = new AndOperator(PolicyType.Global, "bla", PriceGreaterThanLeaf, PriceLessThanLeaf, 8);
AndHas1opSun = new AndOperator(PolicyType.Global, "bla", AndHas0opSun, UsernameEqualsLeaf2, 9);
OrHas0opSun = new OrOperator(PolicyType.Global, "bla", QuantityLessThanLeaf, QuantityGreaterThanLeaf, 10);
OrHas1opSun = new OrOperator(PolicyType.Global, "bla", OrHas0opSun, UsernameEqualsLeaf, 11);
NotHasCondSun = new NotOperator(PolicyType.Global, "bla", AddressEqualsLeaf, null, 12);
NotHasopSun = new NotOperator(PolicyType.Global, "bla", NotHasCondSun, null, 13);
OrHas2opSuns = new OrOperator(PolicyType.Global, "bla", AndHas1opSun, OrHas1opSun, 14);
ROOT_AndHas2opSuns = new AndOperator(PolicyType.Global, "bla", OrHas2opSuns, NotHasopSun, 15);
BadInputLeaf = new UsernameEquals(PolicyType.Global, "bla", "bla'bla", 1);
}
public void Interpret_GoodValues_ReturnsExpression()
{
//Arrange
var interpreter = new QueryFilterInterpreter();
var expression = new NotOperator()
{
Operand = new AndOperator()
{
LeftOperand = new GreaterThanCondition()
{
Property = "Length",
Value = 0
},
RightOperand = new LessThanCondition()
{
Property = "Length",
Value = 6
}
}
};
var entityParameter = Expression.Parameter(typeof(string));
//Act
var result = interpreter.Interpret(expression, entityParameter);
//Assert
Assert.AreEqual(ExpressionType.Not, result.NodeType);
var lambda = Expression.Lambda(Expression.Convert(result, typeof(bool)), entityParameter);
var value = lambda.Compile().DynamicInvoke("Nice");
Assert.AreEqual(false, value);
}
public void AndOrNotTest()
{
Parser parser = new Parser();
BooleanExpression expression = parser.Parse(
"(R:HumanSR OR R:GeneralManagers) AND NOT R:HRSpecialist");
AndOperator andOperator = (AndOperator)expression;
OrOperator orOperator = (OrOperator)andOperator.Left;
RoleExpression hrRoleExpression = (RoleExpression)orOperator.Left;
Assert.AreEqual("HumanSR", hrRoleExpression.Word.Value);
RoleExpression gmRoleExpression = (RoleExpression)orOperator.Right;
Assert.AreEqual("GeneralManagers", gmRoleExpression.Word.Value);
NotOperator notOperator = (NotOperator)andOperator.Right;
RoleExpression specialistRoleExpression = (RoleExpression)notOperator.Expression;
Assert.AreEqual("HRSpecialist", specialistRoleExpression.Word.Value);
}
public void Interpret_GoodValues_ReturnsExpression()
{
//Arrange
var interpreter = new QueryFilterInterpreter();
var expression = new NotOperator()
{
Operand = new AndOperator()
{
LeftOperand = new GreaterThanCondition()
{
Property = "Length",
Value = 0
},
RightOperand = new LessThanCondition()
{
Property = "Length",
Value = 6
}
}
};
var entityParameter = Expression.Parameter(typeof(string));
//Act
var result = interpreter.Interpret(expression, entityParameter);
//Assert
Assert.AreEqual(ExpressionType.Not, result.NodeType);
var lambda = Expression.Lambda(Expression.Convert(result, typeof(bool)), entityParameter);
var value = lambda.Compile().DynamicInvoke("Nice");
Assert.AreEqual(false, value);
}
public void ExtractNotOperator()
{
var notOperator = new NotOperator();
CriteriaOperatorExtractor binaryOperatorExtractor = GetBinaryOperatorExtractor(notOperator);
Assert.AreEqual(notOperator, binaryOperatorExtractor.NotOperators[0]);
}
public void ReplaceNestedOperator()
{
var unaryOperator = new UnaryOperator(UnaryOperatorType.BitwiseNot, "pro");
CriteriaOperator criteriaOperator = new GroupOperator(new BinaryOperator(), unaryOperator);
var binaryOperatorExtractor = new CriteriaOperatorExtractor();
var notOperator = new NotOperator();
binaryOperatorExtractor.Replace(ref criteriaOperator, unaryOperator.ToString(), notOperator);
Assert.AreEqual(((GroupOperator) criteriaOperator).Operands[1], notOperator);
}
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})");
}
}
public static IList <WeeklyInventory> GetThisWeeksInventroy(DateTime StartDate, DateTime EndDate, IObjectSpace space)
{
IList <WeeklyInventory> weeklyInventory = new List <WeeklyInventory>();
// IObjectSpace space = AppHelper.Application.CreateObjectSpace();
//get the list of locations
IList <Location> locationList = space.GetObjects <Location>();
bool groupCheck = false;
foreach (Location loc in locationList)
{
//filter the measures by LDC and date
if (loc.Name.Contains("IPS"))
{
Console.Write('s');
}
WeeklyInventory WeekI = new WeeklyInventory();
WeekI.Location = loc;
XPCollection <Move> moves = loc.MoveFrom;
// BetweenOperator betOp = new BetweenOperator("MoveDate", DateTime.Now.AddDays(-97), DateTime.Now.AddDays(-90));
BetweenOperator betOp = new BetweenOperator("MoveDate", StartDate, EndDate);
NotOperator notOP = new NotOperator(new NullOperator("Appliance"));
GroupOperator grpOP = new GroupOperator();
grpOP.OperatorType = GroupOperatorType.And;
grpOP.Operands.Add(betOp);
grpOP.Operands.Add(notOP);
moves.Filter = grpOP;
// moves.Filter = betOp;
List <InventoryItem> invList = new List <InventoryItem>();
//loc.MoveFrom[0].Appliance
foreach (Move mov in moves)
{
FastFileLineItem item = space.FindObject <FastFileLineItem>(new BinaryOperator("Move.Oid", mov.Oid.ToString()));
foreach (InventoryItem inv in invList)
{
if (item.HAPApplication != null && mov.Appliance.SageName == inv.Appliance.SageName && mov.LocationTo.Name == inv.LocationTo.Name &&
item.HAPApplication.BasicScheduledDate.ToString("dd/MM/yyyy") == inv.InstallDate.ToString("dd/MM/yyyy"))
{
inv.Quantity += mov.Quantity;
groupCheck = true;
}
else if (item.ENBLIApplication != null && mov.Appliance.SageName == inv.Appliance.SageName && mov.LocationTo.Name == inv.LocationTo.Name &&
item.ENBLIApplication.TAPSAssessmentDate.ToString("dd/MM/yyyy") == inv.InstallDate.ToString("dd/MM/yyyy"))
{
inv.Quantity += mov.Quantity;
groupCheck = true;
}
else if (item.ENBLIApplication != null && mov.Appliance.SageName == inv.Appliance.SageName && mov.LocationTo.Name == inv.LocationTo.Name &&
item.ENBLIApplication.ENBLIADate.ToString("dd/MM/yyyy") == inv.InstallDate.ToString("dd/MM/yyyy"))
{
inv.Quantity += mov.Quantity;
groupCheck = true;
}
}
if (!groupCheck)
{
if (item.HAPApplication != null)
{
InventoryItem invItem = new InventoryItem();
invItem.Appliance = mov.Appliance;
invItem.LocationTo = mov.LocationTo;
invItem.Quantity = mov.Quantity;
invItem.InstallDate = item.HAPApplication.BasicScheduledDate;
invList.Add(invItem);
}
else if (item.ENBLIApplication != null)
{
InventoryItem invItem = new InventoryItem();
invItem.Appliance = mov.Appliance;
invItem.LocationTo = mov.LocationTo;
invItem.Quantity = mov.Quantity;
if (item.ENBLIApplication.TAPSAssessmentDate != null && item.ENBLIApplication.TAPSAssessmentDate != DateTime.MinValue)
{
invItem.InstallDate = item.ENBLIApplication.TAPSAssessmentDate;
}
else
{
invItem.InstallDate = item.ENBLIApplication.ENBLIADate;
}
invList.Add(invItem);
}
}
groupCheck = false;
}
if (invList.Count > 0)
{
WeekI.InventoryItemList = invList;
weeklyInventory.Add(WeekI);
}
}
return(weeklyInventory);
}
public void FalseTest()
{
MockExpression expression = new MockExpression(true);
NotOperator notExpression = new NotOperator(expression);
Assert.IsFalse(notExpression.Evaluate(this.principal));
}
public void TrueTest()
{
MockExpression expression = new MockExpression(false);
NotOperator notExpression = new NotOperator(expression);
Assert.IsTrue(notExpression.Evaluate(principal));
}
