public void Test_Circular_Reference1()
{
var ce = new CalculationEngine();
var context = new ExpressionContext();
var variables = context.Variables;
variables.Add("x", 100);
ce.Add("a", "x * 2", context);
variables.Add("y", 1);
ce.Add("b", "a + y + b", context);
ce.Recalculate("a");
}
public void Test_MutipleIdentical_References()
{
var ce = new CalculationEngine();
var context = new ExpressionContext();
var variables = context.Variables;
variables.Add("x", 100);
ce.Add("a", "x * 2", context);
ce.Add("b", "a + a + a", context);
ce.Recalculate("a");
var result = ce.GetResult <int>("b");
Assert.AreEqual((100 * 2) * 3, result);
}
public void Test_Recalculate_NonSource()
{
var ce = new CalculationEngine();
var context = new ExpressionContext();
var variables = context.Variables;
variables.Add("x", 100);
ce.Add("a", "x * 2", context);
variables.Add("y", 1);
ce.Add("b", "a + y", context);
ce.Add("c", "b * 2", context);
ce.Recalculate("a", "b");
var result = ce.GetResult <int>("c");
Assert.AreEqual(((100) * 2 + 1) * 2, result);
}
public void Test_And_Or_Xor_Not_Operators()
{
var ce = new CalculationEngine();
var context = new ExpressionContext();
var variables = context.Variables;
variables.Add("a", 10);
ce.Add("x", "a > 100", context);
ce.Recalculate("x");
var result = ce.GetResult <bool>("x");
Assert.IsFalse(result);
ce.Remove("x");
variables.Add("b", 100);
ce.Add("x", "b = 100", context);
ce.Recalculate("x");
result = ce.GetResult <bool>("x");
Assert.IsTrue(result);
}
public void Test_Complex()
{
var ce = new CalculationEngine();
var context = new ExpressionContext();
var variables = context.Variables;
variables.Add("x", 100);
ce.Add("a", "x * 2", context);
variables.Add("y", 24);
ce.Add("b", "y * 2", context);
ce.Add("c", "a + b", context);
ce.Add("d", "80", context);
ce.Add("e", "a + b + c + d", context);
ce.Recalculate("d");
ce.Recalculate("a", "b");
var result = ce.GetResult <int>("e");
Assert.AreEqual((100 * 2) + (24 * 2) + ((100 * 2) + (24 * 2)) + 80, result);
}
public void Test_Shift_Operators()
{
var ce = new CalculationEngine();
var context = new ExpressionContext();
var variables = context.Variables;
ce.Add("x", "100 >> 2", context);
ce.Recalculate("x");
var result = ce.GetResult <bool>("x");
Assert.IsTrue(result);
}
public void Test_Comparison_Operators()
{
var ce = new CalculationEngine();
var context = new ExpressionContext();
var variables = context.Variables;
variables.Add("a", 10);
ce.Add("x", "a <> 100", context);
ce.Recalculate("x");
var result = ce.GetResult <bool>("x");
Assert.IsTrue(result);
}
public void Test_Arithmetic()
{
var ce = new CalculationEngine();
var context = new ExpressionContext();
var variables = context.Variables;
variables.Add("a", 10);
variables.Add("b", 20);
ce.Add("x", "((a * 2) + (b ^ 2)) - (100 % 5)", context);
ce.Recalculate("x");
var result = ce.GetResult <int>("x");
Assert.AreEqual(420, result);
}
public void Test_Basic()
{
var ce = new CalculationEngine();
var context = new ExpressionContext();
var variables = context.Variables;
variables.Add("x", 100);
ce.Add("a", "x * 2", context);
variables.Add("y", 1);
ce.Add("b", "a + y", context);
ce.Add("c", "b * 2", context);
ce.Recalculate("a");
var result = ce.GetResult <int>("c");
Assert.AreEqual(result, ((100 * 2) + 1) * 2);
variables.Remove("x");
variables.Add("x", 345);
ce.Recalculate("a");
result = ce.GetResult <int>("c");
Assert.AreEqual(((345 * 2) + 1) * 2, result);
}
public void TestBasic()
{
CalculationEngine ce = new CalculationEngine();
ExpressionContext context = new ExpressionContext();
VariableCollection variables = context.Variables;
variables.Add("x", 100);
ce.Add("a", "x * 2", context);
variables.Add("y", 1);
ce.Add("b", "a + y", context);
ce.Add("c", "b * 2", context);
ce.Recalculate("a");
int result = ce.GetResult<int>("c");
Assert.AreEqual(result, ((100 * 2) + 1) * 2);
variables["x"] = 345;
ce.Recalculate("a");
result = ce.GetResult<int>("c");
Assert.AreEqual(((345 * 2) + 1) * 2, result);
}
public void TestCalcEngineAtom()
{
// Test that calc engine atom reference work properly
CalculationEngine engine = new CalculationEngine();
ExpressionContext context = new ExpressionContext();
engine.Add("a", "\"abc\"", context);
engine.Add("b", "a.length", context);
engine.Add("c", "a.startswith(\"a\")", context);
int result = engine.GetResult<int>("b");
Assert.AreEqual("abc".Length, result);
Assert.AreEqual(true, engine.GetResult<bool>("c"));
}
/// <summary>
/// 构建一次ExpressionContext，CalculationEngine
/// </summary>
/// <returns></returns>
public static double Test2()
{
Stopwatch stopwatch2 = new Stopwatch();
stopwatch2.Start();
CalculationEngine calculationEngine = new CalculationEngine();
ExpressionContext context = new ExpressionContext();
VariableCollection variables = context.Variables;
variables.Add("x", 100);
variables.Add("y", 200);
calculationEngine.Add("a", "x+y", context);
for (int i = 0; i < 1000000; i++)
{
variables["x"] = i;
calculationEngine.Recalculate("a");
int j = calculationEngine.GetResult <int>("a");
}
stopwatch2.Stop();
return(stopwatch2.ElapsedMilliseconds);
}
public void TestWithReferenceTypes()
{
CalculationEngine ce = new CalculationEngine();
ExpressionContext context = new ExpressionContext();
VariableCollection variables = context.Variables;
variables.Add("x", "string");
ce.Add("a", "x + \" \"", context);
variables.Add("y", "word");
ce.Add("b", "y", context);
ce.Add("c", "a + b", context);
ce.Recalculate("b", "a");
string result = ce.GetResult<string>("c");
Assert.AreEqual("string" + " " + "word", result);
}
public void TestRemove1()
{
CalculationEngine ce = new CalculationEngine();
ExpressionContext context = new ExpressionContext();
VariableCollection variables = context.Variables;
ce.Add("a", "100", context);
ce.Add("b", "200", context);
ce.Add("c", "a + b", context);
ce.Add("d", "300", context);
ce.Add("e", "c + d", context);
ce.Remove("a");
// Only b and d should remain
Assert.AreEqual(2, ce.Count);
ce.Remove("b");
Assert.AreEqual(1, ce.Count);
ce.Remove("d");
Assert.AreEqual(0, ce.Count);
// b and d should have no dependents or precedents
Assert.IsFalse(ce.HasDependents("b"));
Assert.IsFalse(ce.HasDependents("d"));
Assert.IsFalse(ce.HasPrecedents("b"));
Assert.IsFalse(ce.HasPrecedents("d"));
}
public void TestRemove4()
{
CalculationEngine ce = new CalculationEngine();
ExpressionContext context = new ExpressionContext();
VariableCollection variables = context.Variables;
ce.Add("a", "100", context);
ce.Add("b", "200", context);
ce.Add("c", "a + b", context);
ce.Add("d", "300 + c", context);
ce.Add("e", "c + d", context);
ce.Remove("a");
Assert.AreEqual(1, ce.Count);
ce.Remove("b");
Assert.AreEqual(0, ce.Count);
}
public void TestRecalculateNonSource()
{
// Test recalculate with a non-source
CalculationEngine ce = new CalculationEngine();
ExpressionContext context = new ExpressionContext();
VariableCollection variables = context.Variables;
variables.Add("x", 100);
ce.Add("a", "x * 2", context);
variables.Add("y", 1);
ce.Add("b", "a + y", context);
ce.Add("c", "b * 2", context);
ce.Recalculate("a", "b");
int result = ce.GetResult<int>("c");
Assert.AreEqual(((100) * 2 + 1) * 2, result);
}
public void TestMutipleIdenticalReferences()
{
CalculationEngine ce = new CalculationEngine();
ExpressionContext context = new ExpressionContext();
VariableCollection variables = context.Variables;
variables.Add("x", 100);
ce.Add("a", "x * 2", context);
ce.Add("b", "a + a + a", context);
ce.Recalculate("a");
int result = ce.GetResult<int>("b");
Assert.AreEqual((100 * 2) * 3, result);
}
public void CalcEngine_Returns_Same_Values_As_VB()
{
variables.Add("x", 100);
ce.Add("a", "x * 2", context);
variables.Add("y", 1);
ce.Add("b", "a + y", context);
ce.Add("c", "b * 2", context);
ce.Recalculate("a");
var result = ce.GetResult("c");
Assert.AreEqual(result, ((100 * 2) + 1) * 2);
variables["x"] = 345;
ce.Recalculate("a");
result = ce.GetResult("c");
Assert.AreEqual(((345 * 2) + 1) * 2, result);
}
public void TestDependencyManagement()
{
// Test that we are keeping accurate stats on our dependencies
CalculationEngine engine = new CalculationEngine();
ExpressionContext context = new ExpressionContext();
engine.Add("a", "100", context);
engine.Add("b", "100", context);
// Nothing should point to a and b
Assert.IsFalse(engine.HasPrecedents("a"));
Assert.IsFalse(engine.HasPrecedents("b"));
Assert.IsFalse(engine.HasDependents("a"));
Assert.IsFalse(engine.HasDependents("b"));
engine.Add("c", "a + b", context);
engine.Add("d", "a + c", context);
// a and b still have nothing pointing to them
Assert.IsFalse(engine.HasPrecedents("a"));
Assert.IsFalse(engine.HasPrecedents("b"));
// but they have dependents
Assert.IsTrue(engine.HasDependents("a"));
Assert.IsTrue(engine.HasDependents("b"));
// c and d have precedents
Assert.IsTrue(engine.HasPrecedents("d"));
Assert.IsTrue(engine.HasPrecedents("c"));
// and only c should have dependents
Assert.IsTrue(engine.HasDependents("c"));
Assert.IsFalse(engine.HasDependents("d"));
// test our counts
Assert.AreEqual(2, engine.GetDependents("a").Length);
Assert.AreEqual(1, engine.GetDependents("b").Length);
Assert.AreEqual(1, engine.GetDependents("c").Length);
Assert.AreEqual(0, engine.GetDependents("d").Length);
Assert.AreEqual(0, engine.GetPrecedents("a").Length);
Assert.AreEqual(0, engine.GetPrecedents("b").Length);
Assert.AreEqual(2, engine.GetPrecedents("c").Length);
Assert.AreEqual(2, engine.GetPrecedents("d").Length);
engine.Remove("d");
Assert.IsFalse(engine.HasDependents("c"));
Assert.IsFalse(engine.HasDependents("d"));
Assert.IsFalse(engine.HasPrecedents("d"));
Assert.IsTrue(engine.HasPrecedents("c"));
Assert.AreEqual(1, engine.GetDependents("a").Length);
Assert.AreEqual(1, engine.GetDependents("b").Length);
Assert.AreEqual(0, engine.GetDependents("c").Length);
engine.Remove("c");
Assert.IsFalse(engine.HasPrecedents("c"));
Assert.IsFalse(engine.HasDependents("c"));
Assert.IsFalse(engine.HasDependents("a"));
Assert.IsFalse(engine.HasDependents("b"));
Assert.AreEqual(0, engine.GetDependents("a").Length);
Assert.AreEqual(0, engine.GetDependents("b").Length);
engine.Remove("a");
engine.Remove("b");
Assert.IsFalse(engine.HasDependents("a"));
Assert.IsFalse(engine.HasPrecedents("a"));
Assert.IsFalse(engine.HasDependents("b"));
Assert.IsFalse(engine.HasPrecedents("b"));
Assert.AreEqual(0, engine.GetDependents("a").Length);
Assert.AreEqual(0, engine.GetDependents("b").Length);
Assert.AreEqual(0, engine.GetPrecedents("a").Length);
Assert.AreEqual(0, engine.GetPrecedents("b").Length);
}
public void TestComplex()
{
CalculationEngine ce = new CalculationEngine();
ExpressionContext context = new ExpressionContext();
VariableCollection variables = context.Variables;
variables.Add("x", 100);
ce.Add("a", "x * 2", context);
variables.Add("y", 24);
ce.Add("b", "y * 2", context);
ce.Add("c", "a + b", context);
ce.Add("d", "80", context);
ce.Add("e", "a + b + c + d", context);
ce.Recalculate("d");
ce.Recalculate(new string[] {
"a",
"b"
});
int result = ce.GetResult<int>("e");
Assert.AreEqual((100 * 2) + (24 * 2) + ((100 * 2) + (24 * 2)) + 80, result);
}
public void TestCircularReference1()
{
CalculationEngine ce = new CalculationEngine();
ExpressionContext context = new ExpressionContext();
VariableCollection variables = context.Variables;
variables.Add("x", 100);
ce.Add("a", "x * 2", context);
variables.Add("y", 1);
ce.Add("b", "a + y + b", context);
ce.Recalculate("a");
}
public void TestClear()
{
CalculationEngine engine = new CalculationEngine();
ExpressionContext context = new ExpressionContext();
engine.Add("a", "100", context);
engine.Add("b", "a + 2", context);
engine.Clear();
Assert.IsFalse(engine.HasDependents("a"));
Assert.IsFalse(engine.HasPrecedents("b"));
Assert.AreEqual(0, engine.Count);
}
