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 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 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 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 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 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 TestDottedAssignmentLong()
{
VariableSet vars = new VariableSet();
VariableSet childVars = new VariableSet();
vars.RegisterVariable(OperandType.VSet, "Child", childVars);
vars.RegisterVariable(OperandType.Long, "Child.childLong", 6L);
var actualResultTemp = vars.GetVariable("Child.childLong").Value;
var actualResult = (long)vars.GetVariable("Child.childLong").Value;
long expectedResult = 6;
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 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 TestSimpleAssignment()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.Long, "Age", 42);
var compiledExpression = e.Parse("Age=9");
var evalResult = compiledExpression.Evaluate(variables);
Assert.AreEqual(1, evalResult.Count);
var actualResult = (long)evalResult.Pop().GetValue();
var variable = variables.GetVariable("Age");
Assert.AreEqual(OperandType.Long, (variable.VariableType));
Assert.AreEqual(9, (long)(variable.Value));
Assert.AreEqual(9, actualResult);
}
public void UnregisterMissingVariable()
{
VariableSet vSet = new VariableSet();
Variable inScope = new Variable("Horace", OperandType.String, "I am hungry");
vSet.RegisterVariable(inScope);
Assert.IsTrue(vSet.GetVariable("Horace") == inScope);
try
{
vSet.UnregisterVariable(inScope);
}
catch (KeyNotFoundException knfex)
{
}
}
private void TestRegister(VariableSet vSet, OperandType type, object initialValue, object expectedValue, bool expectedSucceed)
{
try
{
var variable = vSet.RegisterVariable(type, "testName", initialValue);
Assert.AreEqual(true, expectedSucceed);
Assert.AreEqual(expectedValue, vSet.GetVariable("testName").Value);
vSet.UnregisterVariable(variable);
}
catch (InvalidCastException ice)
{
Assert.AreEqual(false, expectedSucceed);
}
catch (NullReferenceException nre)
{
Assert.AreEqual(false, expectedSucceed);
}
}
public void TestLogicalOrBoolWithAssignment()
{
ExpressionParser e = new ExpressionParser();
VariableSet variables = new VariableSet();
variables.RegisterVariable(OperandType.Bool, "IsVisible", false);
variables.RegisterVariable(OperandType.Bool, "IsEnabled", false);
variables.RegisterVariable(OperandType.Bool, "Result", false);
bool expectedResult = false;
var compiledExpression = e.Parse("Result = IsVisible | IsEnabled");
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 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 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 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);
}
