public void TestDoubleAssignmentSecondToFirst()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.Double, "Answer1", 4.2);
variables.RegisterVariable(OperandType.Double, "Answer2", 4.2);
var compiledExpression = e.Parse("Answer1=5.1,Answer2=Answer1");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(2, evalResult.Count);
var actualResult2 = (double)evalResult.Pop().GetValue();
var actualResult1 = (double)evalResult.Pop().GetValue();
var variable1 = variables.GetVariable("Answer1");
var variable2 = variables.GetVariable("Answer2");
var answer1 = 5.1;
var answer2 = 5.1;
Assert.AreEqual(OperandType.Double, (variable1.VariableType));
Assert.AreEqual(OperandType.Double, (variable2.VariableType));
Assert.AreEqual(answer1, (double)(variable1.Value));
Assert.AreEqual(answer2, (double)(variable2.Value));
Assert.AreEqual(answer1, actualResult1);
Assert.AreEqual(answer2, actualResult2);
}
public void TestSpecializedBools()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet(null, new TestVariableFactory());
variables.RegisterVariable(OperandType.NullableBool, "Left", true);
variables.RegisterVariable(OperandType.Bool, "Right", true);
variables.SetVariableValue("Right", false);
variables.SetVariableValue("Right", true);
variables.SetVariableValue("Right", false);
bool?left = true;
bool right = false;
bool expectedResult = left == right;
var compiledExpression = e.Parse("Left == Right");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(1, evalResult.Count);
bool actualResult = (bool)evalResult.Pop().GetValue();
Assert.AreEqual(expectedResult, actualResult);
Assert.AreEqual(3, ((CrazyBool)variables.GetVariable("Right")).ChangeCount);
}
public void TestDoubleAssignmentSecondToSelf()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.Long, "Age", 42);
variables.RegisterVariable(OperandType.Double, "Opacity", 4.2);
variables.RegisterVariable(OperandType.Double, "Answer", 4.2);
var compiledExpression = e.Parse("Answer=5.1,Answer=Answer");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(2, evalResult.Count);
var actualResult2 = evalResult.Pop();
var actualResult1 = evalResult.Pop();
var variable1 = variables.GetVariable("Answer");
var answer1 = 5.1;
var answer2 = 5.1;
Assert.AreEqual(OperandType.Double, (variable1.VariableType));
Assert.AreEqual(answer1, (double)(variable1.Value));
Assert.AreEqual(answer1, actualResult1.GetValue());
Assert.AreEqual(answer2, actualResult2.GetValue());
}
public void DocTest3()
{
// Parse ...
ExpressionParser parser = new ExpressionParser();
var compiledExpression = parser.Parse("(cabbages+onions)*bananas");
Debug.WriteLine(compiledExpression.ToString());
// Variables ...
VariableSet vSet = new VariableSet();
vSet.RegisterVariable(OperandType.Double, "cabbages", 6);
vSet.RegisterVariable(OperandType.Long, "onions", 2);
vSet.RegisterVariable(OperandType.Long, "bananas", 5);
// Evaluate ...
var resultStack = compiledExpression.Evaluate(vSet);
Debug.WriteLine(TokenService.TokensAsString(resultStack));
// Result ...
IOperand result = resultStack.Pop();
Debug.WriteLine($"{result.Type}, {result.GetValue()}");
double answer = (double)result.GetValue();
Debug.WriteLine(answer);
}
public void AdvancedDocumentationSample()
{
///////////////////////////////////////////////
// Create and configure the Parser object ...
///////////////////////////////////////////////
ExpressionParser parser = new ExpressionParser();
// Overload that will allow a Bool to be appended to a String
// To add a String to a Bool you'll need to add another overload
parser.RegisterOverload("+", OperandType.String, OperandType.Bool,
(left, right) => new Operand(OperandType.String, (string)left.GetValue() + ((bool)right.GetValue()).ToString()));
// A user-defined function
// Note (at time of writing) validation of parameter count for functions isn't robust.
parser.RegisterFunction("StringContains", DoStringContains, 3);
///////////////////////////////////////////////
// Note the comma operator - this expression yields two results each time it is evaluated
// It calls the function 'StringContains' registered above, passing in a variable, a constant and a bool
// It uses the overload registered above to add a bool to a string
///////////////////////////////////////////////
var compiledExpression = parser.Parse(
"text = text + child.textPhrase, 'HammerCat found: ' + (StringContains(text, 'HammerCat', true) >= 0)"
);
///////////////////////////////////////////////
// Configure a VariableSet with a custom factory
///////////////////////////////////////////////
var variableFactory = new TestVariableFactory();
VariableSet vSet = new VariableSet(variableFactory);
vSet.RegisterVariable(OperandType.String, "text", "GO!-> ");
vSet.RegisterVariable(OperandType.VSet, "child", new VariableSet(variableFactory)); // VariableSet - same factory
vSet.RegisterVariable(OperandType.String, "child.textPhrase", "Who seeks HammerCat?"); // Nested Variable
///////////////////////////////////////////////
// Evaluate ...
///////////////////////////////////////////////
var resultStack = compiledExpression.Evaluate(vSet);
///////////////////////////////////////////////
// Get both of the results ...
///////////////////////////////////////////////
// Result of "'HammerCat found: ' + StringContains(text, 'HammerCat', true) >= 0"
var second = (string)resultStack.Pop().GetValue();
// Result of "text = text + child.textPhrase"
var first = (string)resultStack.Pop().GetValue();
// Ensure the result matches the variable ...
string text = (string)vSet.GetVariable("text").Value;
Assert.AreEqual(first, text);
// Show the results ...
Debug.WriteLine($"First result is: {first}");
Debug.WriteLine($"Second result is: {second}");
ShowCustomVariables("", vSet);
}
public void TestSimpleDottedLookup()
{
VariableSet daddyVarbs = new VariableSet();
VariableSet childVarbs = new VariableSet();
daddyVarbs.RegisterVariable(OperandType.Long, "daddyLong", 5);
childVarbs.RegisterVariable(OperandType.Long, "childLong", 6);
childVarbs.RegisterVariable(OperandType.VSet, "daddy", daddyVarbs);
var actualResult = (long)childVarbs.GetVariable("daddy.daddyLong").Value;
long expectedResult = 5;
Assert.AreEqual(expectedResult, actualResult);
}
public void UnregisterNestedVariable()
{
VariableSet vSet = new VariableSet();
VariableSet childVset = new VariableSet();
Variable inScope = new Variable("Horace", OperandType.String, "I am hungry");
vSet.RegisterVariable(OperandType.VSet, "child", childVset);
childVset.RegisterVariable(inScope);
Assert.IsTrue(vSet.GetVariable("child.Horace") == inScope);
vSet.UnregisterVariable("child.Horace");
try
{
var variable = vSet.GetVariable("Horace");
Assert.Fail("Did not throw expected exception");
}
catch (KeyNotFoundException knfex)
{
}
catch
{
Assert.Fail("Did not throw expected exception");
}
}
public void TestMissingVariable3()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.String, "Banana", "Hello Banana!");
IOperand actualResult1 = null;
Stack <IOperand> evalResult = null;
bool shortedOut = true;
var compiledExpression = e.Parse("Banana , Melon");
try
{
evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(2, evalResult.Count);
shortedOut = false;
actualResult1 = OperatorActions.PopAndResolve(evalResult, variables);
}
catch (ExpressionEvaluatorException ex)
{
Assert.AreEqual(shortedOut, false);
Assert.AreEqual(actualResult1, null);
var actualResult2 = OperatorActions.PopAndResolve(evalResult, variables).GetValue();
Assert.AreEqual((string)actualResult2, "Hello Banana!");
Assert.AreEqual(ex.Cause, ExpressionEvaluatorException.ExceptionCause.UndefinedVariable);
Assert.AreEqual(ex.Offset, 9);
Assert.AreEqual(ex.Message, "'Melon'");
}
}
public void TestMatchSimpleString()
{
ExpressionParser e = new ExpressionParser();
e.RegisterFunction("StringContains", DoStringContains, 2);
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.String, "Name", "This is a test");
variables.RegisterVariable(OperandType.String, "SubString", "is");
var compiledExpression = e.Parse("StringContains(Name, SubString)");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(1, evalResult.Count);
Assert.AreEqual(true, (bool)evalResult.Pop().GetValue());
}
public void TestDoubleDottedAssignment()
{
VariableSet vars = new VariableSet();
VariableSet childVars = new VariableSet();
VariableSet grandchildVars = new VariableSet();
vars.RegisterVariable(OperandType.VSet, "Child", childVars);
vars.RegisterVariable(OperandType.VSet, "Child.Child", grandchildVars);
vars.RegisterVariable(OperandType.Long, "Child.Child.childLong", 6);
var actualResult = (long)vars.GetVariable("Child.Child.childLong").Value;
long expectedResult = 6;
Assert.AreEqual(expectedResult, actualResult);
}
public void TestComplexLogicalOperators()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.Long, "L0", 42);
variables.RegisterVariable(OperandType.Long, "L1", -129);
variables.RegisterVariable(OperandType.Long, "L2", -475);
variables.RegisterVariable(OperandType.Bool, "B0", false);
variables.RegisterVariable(OperandType.Bool, "B1", true);
variables.RegisterVariable(OperandType.Bool, "B2", true);
variables.RegisterVariable(OperandType.Bool, "Result", false);
long l0 = 42, l1 = -129, l2 = -475;
bool b0 = false, b1 = true, b2 = true;
bool expectedResult = b0 | (b1 & b2) == true & ((l0 & l1) > 11);
var compiledExpression = e.Parse("Result = B0 | (B1 & B2) == True & ( (L0 & L1) > 11)");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(1, evalResult.Count);
bool actualResult = (bool)evalResult.Pop().GetValue();
Assert.AreEqual(expectedResult, variables.GetVariable("Result").Value);
Assert.AreEqual(expectedResult, actualResult);
}
public void TestSimpleLogicalComplementLong()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.Long, "Var0", 42);
variables.RegisterVariable(OperandType.Long, "Var1", -402);
long expectedResult = 42 + ~-402;
var compiledExpression = e.Parse("Var0 +~ Var1");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(1, evalResult.Count);
long actualResult = (long)evalResult.Pop().GetValue();
Assert.AreEqual(expectedResult, actualResult);
}
public void TestSimpleModuloLong2()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.Long, "Var0", 42);
variables.RegisterVariable(OperandType.Long, "Var1", -402);
long expectedResult = ~42 % -402 % ~9;
var compiledExpression = e.Parse("~Var0 % ~Var1 % ~9");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(1, evalResult.Count);
long actualResult = (long)evalResult.Pop().GetValue();
Assert.AreEqual(expectedResult, actualResult);
}
public void TestSimpleLogicalOrBool2()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.Bool, "IsVisible", false);
variables.RegisterVariable(OperandType.Bool, "IsEnabled", false);
bool expectedResult = false;
var compiledExpression = e.Parse("IsVisible | IsEnabled");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(1, evalResult.Count);
bool actualResult = (bool)evalResult.Pop().GetValue();
Assert.AreEqual(expectedResult, actualResult);
}
public void TestRegisterMultiOverloadToUnaryOperand()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.Long, "Age", 42);
variables.RegisterVariable(OperandType.Double, "Opacity", 0.23);
variables.RegisterVariable(OperandType.String, "Name", "Valerie");
try
{
e.RegisterOverload("!", OperandType.Long, OperandType.String,
(leftOperand, rightOperand) => new Operand(OperandType.String, (string)leftOperand.GetValue() + (long)rightOperand.GetValue()));
}
catch (ExpressionParserException ex)
{
Assert.AreEqual(-1, ex.Offset);
Assert.AreEqual(ExpressionParserException.ExceptionCause.DoubleOperandOperatorNotFound, ex.Cause);
}
}
public void TestNestedFunctionCalls()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.Long, "Age", 42);
variables.RegisterVariable(OperandType.Double, "Opacity", 0.23);
variables.RegisterVariable(OperandType.String, "Name", "Brian");
double expectedResult = (mul(42 + 3, mul(9, 6)) * mul(7 - 4, mul(5, 6)) / 12 + -5) / 0.23;
var compiledExpression = e.Parse("(_debug_mul(Age + 3, _debug_mul(9,6))*_debug_mul(7 - 4, _debug_mul(5,6))/12 + -5)/Opacity");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(1, evalResult.Count);
var actualResult = (double)evalResult.Pop().GetValue();
Assert.AreEqual(expectedResult, actualResult);
}
public void TestComplexExpression()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.Long, "Age", 42);
variables.RegisterVariable(OperandType.Double, "Opacity", 0.23);
variables.RegisterVariable(OperandType.String, "Name", "Brian");
double expectedResult = ((42 + 3) * (7 - 4) / 12 + -5) / 0.23;
var compiledExpression = e.Parse("((Age + 3)*(7 - 4)/12 + -5)/Opacity");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(1, evalResult.Count);
var actualResult = (double)evalResult.Pop().GetValue();
Assert.AreEqual(expectedResult, actualResult);
}
public void TestTypeFail()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.Long, "Age", 42);
variables.RegisterVariable(OperandType.String, "Name", "Brian");
var compiledExpression = e.Parse("Age * Name");
try
{
var evalResult = compiledExpression.Evaluate(variables);
}
catch (ExpressionEvaluatorException ex)
{
Assert.AreEqual(ex.Cause, ExpressionEvaluatorException.ExceptionCause.BadOperand);
Assert.AreEqual(ex.Offset, 4);
}
}
public void TestSimpleLogicalNotLong()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.Long, "Var0", 42);
variables.RegisterVariable(OperandType.Long, "Var1", -402);
try
{
var compiledExpression = e.Parse("Var0 |! Var1");
var evalResult = compiledExpression.Evaluate(variables);
}
catch (ExpressionEvaluatorException ex)
{
Assert.AreEqual(6, ex.Offset);
Assert.AreEqual(ExpressionEvaluatorException.ExceptionCause.BadUnaryOperand, ex.Cause);
return;
}
Assert.Fail("Did not throw correct exception");
}
public void TestDottedLookup()
{
ExpressionParser e = new ExpressionParser();
VariableSet daddyVarbs = new VariableSet();
VariableSet childVarbs = new VariableSet();
daddyVarbs.RegisterVariable(OperandType.Long, "daddyLong", 5);
childVarbs.RegisterVariable(OperandType.Long, "childLong", 6);
childVarbs.RegisterVariable(OperandType.VSet, "daddy", daddyVarbs);
long expectedResult = 5 + 6;
var compiledExpression = e.Parse("childLong + daddy.daddyLong");
var evalResult = compiledExpression.Evaluate(childVarbs);
Assert.AreEqual(1, evalResult.Count);
var actualResult = (long)evalResult.Pop().GetValue();
Assert.AreEqual(expectedResult, actualResult);
}
public void TestModuloLongWithAssignment()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.Long, "Var0", 42);
variables.RegisterVariable(OperandType.Long, "Var1", -129);
variables.RegisterVariable(OperandType.Long, "Result", -999);
long expectedResult = 42 % ~-129 % ~9;
var compiledExpression = e.Parse("Result = Var0 %~ Var1 %~ 9");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(1, evalResult.Count);
long actualResult = (long)evalResult.Pop().GetValue();
Assert.AreEqual(expectedResult, variables.GetVariable("Result").Value);
Assert.AreEqual(expectedResult, actualResult);
}
public void TestSimpleLookup()
{
VariableSet childVarbs = new VariableSet();
childVarbs.RegisterVariable(OperandType.Long, "childLong", 6);
var actualResult = (long)childVarbs.GetVariable("childLong").Value;
long expectedResult = 6;
Assert.AreEqual(expectedResult, actualResult);
}
public void TestNullableLongNullAddLong()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.NullableLong, "Left", null);
variables.RegisterVariable(OperandType.Long, "Right", 5);
long?left = null;
long right = 5;
long?expectedResult = left + right;
var compiledExpression = e.Parse("Left + Right");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(1, evalResult.Count);
long?actualResult = (long?)evalResult.Pop().GetValue();
Assert.AreEqual(expectedResult, actualResult);
}
public void TestDottedAssignment()
{
ExpressionParser e = new ExpressionParser();
VariableSet daddyVarbs = new VariableSet();
VariableSet childVarbs = new VariableSet();
daddyVarbs.RegisterVariable(OperandType.Long, "daddyLong", 5);
childVarbs.RegisterVariable(OperandType.Long, "childLongA", 6);
childVarbs.RegisterVariable(OperandType.Long, "childLongB", 7);
childVarbs.RegisterVariable(OperandType.VSet, "daddy", daddyVarbs);
long expectedResult = 6 + 7;
var compiledExpression = e.Parse("daddy.daddyLong = childLongA + childLongB");
var evalResult = compiledExpression.Evaluate(childVarbs);
Assert.AreEqual(1, evalResult.Count);
long actualResult = (long)daddyVarbs.GetVariable("daddyLong").Value;
Assert.AreEqual(expectedResult, actualResult);
}
public void TestSimpleNullableBoolToNullableBoolEquality()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.NullableBool, "Left", true);
variables.RegisterVariable(OperandType.NullableBool, "Right", null);
bool?left = true;
bool?right = false;
bool expectedResult = left == right;
var compiledExpression = e.Parse("Left == Right");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(1, evalResult.Count);
bool actualResult = (bool)evalResult.Pop().GetValue();
Assert.AreEqual(expectedResult, actualResult);
}
public void TestAssignment()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.Long, "Age", 42);
variables.RegisterVariable(OperandType.Double, "Opacity", 4.2);
variables.RegisterVariable(OperandType.Double, "Answer", 4.2);
var compiledExpression = e.Parse("Answer=5+(((Age*Opacity)+6)*9.771)-2");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(1, evalResult.Count);
var actualResult = (double)evalResult.Pop().GetValue();
var expectedResult = 5 + (((42 * 4.2) + 6) * 9.771) - 2;
var variable = variables.GetVariable("Answer");
Assert.AreEqual(OperandType.Double, (variable.VariableType));
Assert.AreEqual(expectedResult, (double)(variable.Value));
Assert.AreEqual(expectedResult, actualResult);
}
public void TestOverloadNotString()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.Long, "Age", 42);
variables.RegisterVariable(OperandType.Double, "Opacity", 0.23);
variables.RegisterVariable(OperandType.String, "Name", "Valerie");
e.RegisterOverload("!", OperandType.String,
(operand) => new Operand(OperandType.String, (string)"!" + (string)operand.GetValue()));
string expectedResult = "!Valerie";
var compiledExpression = e.Parse("!Name");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(1, evalResult.Count);
var actualResult = (string)evalResult.Pop().GetValue();
Assert.AreEqual(expectedResult, actualResult);
}
private async Task <VariableSet> GetOperandChildsAsync(Operand parent, VariableSet variableSet)
{
KeyValuePair <string, double> result;
await _context.Entry(parent).Collection(x => x.Childs).Query().LoadAsync();
var childs = parent.Childs;
if (childs.Count > 1)
{
//caculate child
for (int i = 1; i < childs.Count; i++)
{
Console.WriteLine("i: " + i);
await GetOperandChildsAsync(childs.ElementAt(i), variableSet);
}
//caculate parent
result = await CaculateOperandAsync(parent, variableSet);
Console.WriteLine(result.Key + " " + result.Value);
if (variableSet.Where(x => x.VariableName.Equals(result.Key)).FirstOrDefault() == null)
{
variableSet.RegisterVariable(OperandType.Double, result.Key, result.Value);
}
return(variableSet);
}
else
{
result = await CaculateOperandAsync(parent, variableSet);
Console.WriteLine(result.Key + " " + result.Value);
if (variableSet.Where(x => x.VariableName.Equals(result.Key)).FirstOrDefault() == null)
{
variableSet.RegisterVariable(OperandType.Double, result.Key, result.Value);
}
}
return(variableSet);
}
public void TestVariableValue()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.String, "Banana", "Hello Banana");
var compiledExpression = e.Parse("Banana");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(1, evalResult.Count);
var actualResult = OperatorActions.PopAndResolve(evalResult, variables).GetValue();
Assert.AreEqual("Hello Banana", actualResult);
}
public void TestCompareToNull()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.String, "Name", "Brian");
var compiledExpression = e.Parse("Name != null");
bool expectedResult = true;
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(1, evalResult.Count);
var actualResult = (bool)evalResult.Pop().GetValue();
Assert.AreEqual(expectedResult, actualResult);
}
