public void verify_methods_ambiguity()
{
// since arguments types are not taken under consideration for methods overloading, following logic should fail
var parser = new Parser();
parser.AddFunction <int, string>("Whoami", i => string.Format("utility method {0}", i));
parser.AddFunction <string, string>("Whoami", s => string.Format("utility method {0}", s));
parser.AddFunction <string, string, string>("Glue", (s1, s2) => string.Concat(s1, s2));
parser.AddFunction <int, int, string>("Glue", (i1, i2) => string.Concat(i1, i2));
try
{
Assert.IsTrue(parser.Parse <object>("Whoami(0) == 'utility method 0'").Invoke(null));
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
"Parse error: Function Whoami accepting 1 parameter is ambiguous.",
e.Message);
}
try
{
Assert.IsTrue(parser.Parse <object>("Glue('a', 'b') == 'ab'").Invoke(null));
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
"Parse error: Function Glue accepting 2 parameters is ambiguous.",
e.Message);
}
// not only built-in, but also context extracted methods are subjected to the same rules
parser = new Parser();
var model = new ModelWithAmbiguousMethods();
try
{
Assert.IsTrue(parser.Parse <ModelWithAmbiguousMethods>("Whoami(0) == 'model method 0'").Invoke(model));
Assert.Fail();
}
catch (Exception e)
{
Assert.AreEqual(
"Parse error: Function Whoami accepting 1 parameter is ambiguous.",
e.Message);
}
}
public void verify_methods_overloading() // overloading concept exists, when there are two methods of the same name, but different signature
{
// methods overloading is based on the number of arguments
var parser = new Parser();
parser.AddFunction("Whoami", () => "utility method");
parser.AddFunction <int, string>("Whoami", i => string.Format("utility method {0}", i));
parser.AddFunction <int, string, string>("Whoami", (i, s) => string.Format("utility method {0} - {1}", i, s));
Assert.IsTrue(parser.Parse <object>("Whoami() == 'utility method'").Invoke(null));
Assert.IsTrue(parser.Parse <object>("Whoami(1) == 'utility method 1'").Invoke(null));
Assert.IsTrue(parser.Parse <object>("Whoami(2, 'final') == 'utility method 2 - final'").Invoke(null));
}
public void verify_methods_overloading()
{
// methods overloading is based on the number of arguments
var parser = new Parser();
parser.AddFunction("Whoami", () => "utility method");
parser.AddFunction <int, string>("Whoami", i => string.Format("utility method {0}", i));
parser.AddFunction <int, string, string>("Whoami", (i, s) => string.Format("utility method {0} - {1}", i, s));
Assert.IsTrue(parser.Parse <object>("Whoami() == 'utility method'").Invoke(null));
Assert.IsTrue(parser.Parse <object>("Whoami(1) == 'utility method 1'").Invoke(null));
Assert.IsTrue(parser.Parse <object>("Whoami(2, 'final') == 'utility method 2 - final'").Invoke(null));
}
public void verify_methods_overriding()
{
var parser = new Parser();
// register utility methods
parser.AddFunction("Whoami", () => "utility method");
parser.AddFunction <int, string>("Whoami", i => string.Format("utility method {0}", i));
var model = new ModelWithMethods();
// redefined model methods take precedence
Assert.IsTrue(parser.Parse <ModelWithMethods>("Whoami() == 'model method'").Invoke(model));
Assert.IsTrue(parser.Parse <ModelWithMethods>("Whoami(1) == 'model method 1'").Invoke(model));
}
public void verify_methods_overriding() // overriding concept exists, when there are two methods of the same name and signature, but different implementation
{
var parser = new Parser();
// register utility methods
parser.AddFunction("Whoami", () => "utility method");
parser.AddFunction <int, string>("Whoami", i => string.Format("utility method {0}", i));
var model = new ModelWithMethods();
// redefined model methods take precedence
Assert.IsTrue(parser.Parse <ModelWithMethods>("Whoami() == 'model method'").Invoke(model));
Assert.IsTrue(parser.Parse <ModelWithMethods>("Whoami(1) == 'model method 1'").Invoke(model));
}
public void verify_invalid_arguments_conversion()
{
var parser = new Parser();
parser.AddFunction <object, string>("Whoami", o => string.Format("utility method {0}", o));
parser.AddFunction <int, string, string>("Whoami", (i, s) => string.Format("utility method {0} - {1}", i, s));
Assert.IsTrue(parser.Parse <object>("Whoami('0') == 'utility method 0'").Invoke(null)); // successful conversion from String to Object
Assert.IsTrue(parser.Parse <object>("Whoami(1, '2') == 'utility method 1 - 2'").Invoke(null)); // types matched, no conversion needed
try
{
Assert.IsTrue(parser.Parse <object>("Whoami('1', '2') == 'utility method 1 - 2'").Invoke(null));
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
"Parsing failed. Invalid expression: Whoami('1', '2') == 'utility method 1 - 2'",
e.Message);
Assert.IsNotNull(e.InnerException);
Assert.IsTrue(e.InnerException is InvalidOperationException);
Assert.AreEqual(
"Argument 0 type conversion from String to needed Int32 failed.",
e.InnerException.Message);
}
try
{
Assert.IsTrue(parser.Parse <object>("Whoami(1, 2) == 'utility method 1 - 2'").Invoke(null));
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
"Parsing failed. Invalid expression: Whoami(1, 2) == 'utility method 1 - 2'",
e.Message);
Assert.IsNotNull(e.InnerException);
Assert.IsTrue(e.InnerException is InvalidOperationException);
Assert.AreEqual(
"Argument 1 type conversion from Int32 to needed String failed.",
e.InnerException.Message);
}
}
public void CustomFunctions_Test()
{
var parser = new Parser();
parser.AddFunction("sqr", calc);
parser.AddFunction("add", (a, b) => a + b);
parser.AddFunction("av", (a, b, c) => (a + b + c) / 3);
parser.AddFunction("sumv", calc2);
parser.AddFunction("circ", "pi*r^2", "r");
Assert.IsTrue(Array.IndexOf(parser.CustomFunctions, "add") > -1);
Assert.AreEqual(64516, parser.Parse("sqr254").Evaluate());
Assert.ThrowsException <ParserFunctionArgumentException>(() => parser.Parse("add(1, 2, 3)"));
Assert.AreEqual(20, parser.Parse("av(32, 22, 6)").Evaluate());
Assert.AreEqual(12.9, parser.Parse("sumv(7, -4, -2.5, 12.4)").Evaluate());
Assert.AreEqual(Math.PI * 295.84, parser.Parse("circ(17.2)").Evaluate());
}
public void ArgumentException_InvalidName(string name)
{
var parser = new Parser();
Assert.ThrowsException <ArgumentException>(() => parser.AddFunction(name, "2*x", "x"));
Assert.ThrowsException <ArgumentException>(() => parser.AddVariable(name));
}
public static string Iterative(string sfx, string sfdx, double a, double b, out int count)
{
Parser fx = new Parser(sfx);
fx.AddFunction<Algorithms>("log");
fx.Compile();
Parser fdx = new Parser(sfdx);
fdx.AddFunction<Algorithms>("log");
fdx.Compile();
double x0 = (a + b)/2;
if (x0 == 0)
{
x0 = (b + x0)/2;
}
fdx.Variables.Add("x", x0);
double lambda = -1 / fdx.Calculate();
count = 0;
fx.Variables.Add("x", x0);
double xn = x0 + lambda*fx.Calculate();
while ((xn - x0) > eps)
{
x0 = xn;
fx.Variables["x"] = xn;
xn = xn + lambda * fx.Calculate();
++count;
}
return xn.ToString();
}
public void ArgumentException_AlreadyExists()
{
var parser = new Parser("x");
Assert.ThrowsException <ArgumentException>(() => parser.AddVariable("x"));
Assert.ThrowsException <ArgumentException>(() => parser.AddVariable("sin"));
Assert.ThrowsException <ArgumentException>(() => parser.AddFunction("pi", "2*r", "r"));
}
public void SeparatorStyle_Test()
{
Parser parser = new Parser();
parser.AddFunction("add", calc2);
Assert.AreEqual(1018.65, parser.Parse("add(5.5, 1000.5, 12.65)").Evaluate());
parser.SeparatorStyle = SeparatorStyle.Comma;
Assert.AreEqual(1018.65, parser.Parse("add(5,5; 1000,5; 12,65)").Evaluate());
}
public void IsDefined_Test()
{
var parser = new Parser("x");
parser.AddFunction("sqr", "x^2", "x");
Assert.IsTrue(parser.IsDefined("x"));
Assert.IsTrue(parser.IsDefined("sqr"));
Assert.IsTrue(parser.IsDefined("sin"));
Assert.IsFalse(parser.IsDefined("y"));
}
public static double Parse(string input)
{
Parser OMG = new Parser(input);
OMG.AddFunction<Agent>("F");
OMG.Compile();
OMG.Variables.Add("x",2);
OMG.Variables.Add("y", 2);
OMG.Variables.Add("z", 2);
return OMG.Calculate();
}
private static void ConfigureParser()
{
Parser.AddFunction("pi", new PiFunction());
Parser.AddFunction("sin", new SinFunction());
Parser.AddFunction("cos", new CosFunction());
Parser.AddFunction("tg", new TangentFunction());
Parser.AddFunction("abs", new AbsFunction());
Parser.AddFunction("pow", new PowFunction());
Parser.AddFunction("sqrt", new SqrtFunction());
Parser.AddFunction("exp", new ExpFunction());
}
public void VariablesFunctionsSeparation_Test()
{
var parser = new Parser("x", "y", "z", "a");
Assert.IsTrue(Array.IndexOf(parser.CustomFunctions, "z") == -1);
Assert.ThrowsException <ArgumentException>(() => parser.RemoveFunction("x"));
Assert.IsTrue(Array.IndexOf(parser.CustomVariables, "x") > -1);
parser.AddFunction("fun", "2*x", "x");
Assert.IsNull(parser.GetVariable("fun"));
parser.RemoveAllVariables();
Assert.IsTrue(Array.IndexOf(parser.CustomFunctions, "fun") > -1);
}
public void RemoveFunctions_Test()
{
string[] vars = new string[] { "a", "b", "c", "d", "xyz", "alpha" };
var parser = new Parser();
foreach (var s in vars)
{
parser.AddFunction(s, calc);
}
parser.RemoveFunction("xyz");
Assert.IsFalse(Array.IndexOf(parser.CustomFunctions, "xyz") > -1);
Assert.ThrowsException <ArgumentException>(() => parser.RemoveFunction("xyz"));
parser.RemoveAllFunctions();
foreach (string var in vars)
{
Assert.IsFalse(Array.IndexOf(parser.CustomFunctions, var) > -1);
}
}
public static string Chord(string sfx, string sfdx, double a, double b, out int count)
{
Parser fx = new Parser(sfx);
fx.AddFunction<Algorithms>("log");
fx.Compile();
Parser fdx = new Parser(sfdx);
fdx.AddFunction<Algorithms>("log");
fdx.Compile();
fx.Variables["x"] = a;
fdx.Variables["x"] = a;
double a_fpt = fx.Calculate()*fdx.Calculate();
fx.Variables["x"] = b;
fdx.Variables["x"] = b;
double b_fpt = fx.Calculate()*fdx.Calculate();
double fixedPoint = a_fpt > 0 ? a : b;
double xnm1 = (a + b) / 2;
fx.Variables["x"] = xnm1;
double fx_r = fx.Calculate();
fx.Variables["x"] = fixedPoint;
double fx0_r = fx.Calculate();
double xn = xnm1 - (xnm1 - fixedPoint)/(fx_r - fx0_r)*fx_r;
count = 0;
while ((xn - xnm1) > eps)
{
xnm1 = xn;
fx.Variables["x"] = xn;
fx_r = fx.Calculate();
xn = xn - (xn - fixedPoint) / (fx_r - fx0_r) * fx_r;
++count;
}
return xn.ToString();
}
public void verify_short_circuit_evaluation()
{
var parser = new Parser();
parser.AddFunction <object, bool>("CastToBool", obj => (bool)obj);
try
{
parser.Parse <object>("CastToBool(null)").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is NullReferenceException);
}
// below, the exception should not be thrown as above
// reason? - first argument is suffient to determine the value of the expression so the second one is not going to be evaluated
Assert.IsFalse(parser.Parse <object>("false && CastToBool(null)").Invoke(null));
Assert.IsTrue(parser.Parse <object>("true || CastToBool(null)").Invoke(null));
}
public void verify_short_circuit_evaluation()
{
var parser = new Parser();
parser.AddFunction<object, bool>("CastToBool", obj => (bool) obj);
try
{
parser.Parse<object>("CastToBool(null)").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is NullReferenceException);
}
// below, the exception should not be thrown as above
// reason? - first argument is suffient to determine the value of the expression so the second one is not going to be evaluated
Assert.IsFalse(parser.Parse<object>("false && CastToBool(null)").Invoke(null));
Assert.IsTrue(parser.Parse<object>("true || CastToBool(null)").Invoke(null));
}
public void verify_methods_overriding()
{
var parser = new Parser();
// register utility methods
parser.AddFunction("Whoami", () => "utility method");
parser.AddFunction<int, string>("Whoami", i => string.Format("utility method {0}", i));
var model = new ModelWithMethods();
// redefined model methods take precedence
Assert.IsTrue(parser.Parse<ModelWithMethods>("Whoami() == 'model method'").Invoke(model));
Assert.IsTrue(parser.Parse<ModelWithMethods>("Whoami(1) == 'model method 1'").Invoke(model));
}
public void verify_methods_overloading()
{
// methods overloading is based on the number of arguments
var parser = new Parser();
parser.AddFunction("Whoami", () => "utility method");
parser.AddFunction<int, string>("Whoami", i => string.Format("utility method {0}", i));
parser.AddFunction<int, string, string>("Whoami", (i, s) => string.Format("utility method {0} - {1}", i, s));
Assert.IsTrue(parser.Parse<object>("Whoami() == 'utility method'").Invoke(null));
Assert.IsTrue(parser.Parse<object>("Whoami(1) == 'utility method 1'").Invoke(null));
Assert.IsTrue(parser.Parse<object>("Whoami(2, 'final') == 'utility method 2 - final'").Invoke(null));
}
public void verify_methods_ambiguity()
{
// since arguments types are not taken under consideration for methods overloading, following logic should fail
var parser = new Parser();
parser.AddFunction<int, string>("Whoami", i => string.Format("utility method {0}", i));
parser.AddFunction<string, string>("Whoami", s => string.Format("utility method {0}", s));
parser.AddFunction<string, string, string>("Glue", (s1, s2) => string.Concat(s1, s2));
parser.AddFunction<int, int, string>("Glue", (i1, i2) => string.Concat(i1, i2));
try
{
Assert.IsTrue(parser.Parse<object>("Whoami(0) == 'utility method 0'").Invoke(null));
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 1:
... Whoami(0) == 'utility method 0' ...
^--- Function 'Whoami' accepting 1 argument is ambiguous.",
e.Message);
}
try
{
Assert.IsTrue(parser.Parse<object>("Glue('a', 'b') == 'ab'").Invoke(null));
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 1:
... Glue('a', 'b') == 'ab' ...
^--- Function 'Glue' accepting 2 arguments is ambiguous.",
e.Message);
}
// not only built-in, but also context extracted methods are subjected to the same rules
parser = new Parser();
var model = new ModelWithAmbiguousMethods();
try
{
Assert.IsTrue(parser.Parse<ModelWithAmbiguousMethods>("Whoami(0) == 'model method 0'").Invoke(model));
Assert.Fail();
}
catch (Exception e)
{
Assert.AreEqual(
@"Parse error on line 1, column 1:
... Whoami(0) == 'model method 0' ...
^--- Function 'Whoami' accepting 1 argument is ambiguous.",
e.Message);
}
}
public void verify_implicit_type_conversion()
{
var parser = new Parser();
parser.AddFunction<object, string>("Whoami", o => string.Format("utility method {0}", o));
parser.AddFunction<int, string, string>("Whoami", (i, s) => string.Format("utility method {0} - {1}", i, s));
Assert.IsTrue(parser.Parse<object>("Whoami('0') == 'utility method 0'").Invoke(null)); // successful conversion from String to Object
Assert.IsTrue(parser.Parse<object>("Whoami(1, '2') == 'utility method 1 - 2'").Invoke(null)); // types matched, no conversion needed
try
{
Assert.IsTrue(parser.Parse<object>("Whoami('1', '2') == 'utility method 1 - 2'").Invoke(null));
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 8:
... '1', '2') == 'utility method 1 - 2' ...
^--- Function 'Whoami' 1st argument implicit conversion from 'System.String' to expected 'System.Int32' failed.",
e.Message);
}
try
{
Assert.IsTrue(parser.Parse<object>("Whoami(1, 2) == 'utility method 1 - 2'").Invoke(null));
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 11:
... 2) == 'utility method 1 - 2' ...
^--- Function 'Whoami' 2nd argument implicit conversion from 'System.Int32' to expected 'System.String' failed.",
e.Message);
}
}
static void command_func(string[] args)
{
string[] funcArgs = args[2].Split(',');
parser.AddFunction(args[0], args[1], funcArgs);
}
public void verify_various_parsing_errors()
{
var parser = new Parser();
parser.RegisterMethods();
parser.AddFunction<int, int, int>("Max", (x, y) => Math.Max(x, y));
try
{
parser.Parse<object>("1++ +1==2").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 2:
... ++ +1==2 ...
^--- Unexpected token: '++'.",
e.Message);
}
try
{
parser.Parse<object>("true # false").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... # false ...
^--- Invalid token.",
e.Message);
}
try
{
parser.Parse<object>("'abc' - 'abc'").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 7:
... - 'abc' ...
^--- Operator '-' cannot be applied to operands of type 'System.String' and 'System.String'.",
e.Message);
}
try
{
parser.Parse<object>("0 + null").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 3:
... + null ...
^--- Operator '+' cannot be applied to operands of type 'System.Int32' and 'null'.",
e.Message);
}
try
{
parser.Parse<object>("0 / null").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 3:
... / null ...
^--- Operator '/' cannot be applied to operands of type 'System.Int32' and 'null'.",
e.Message);
}
try
{
parser.Parse<object>("true && null").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... && null ...
^--- Operator '&&' cannot be applied to operands of type 'System.Boolean' and 'null'.",
e.Message);
}
try
{
parser.Parse<object>("true || null").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... || null ...
^--- Operator '||' cannot be applied to operands of type 'System.Boolean' and 'null'.",
e.Message);
}
try
{
parser.Parse<object>("!null").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 1:
... !null ...
^--- Operator '!' cannot be applied to operand of type 'null'.",
e.Message);
}
try
{
parser.Parse<object>("'abc' * 'abc'").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 7:
... * 'abc' ...
^--- Operator '*' cannot be applied to operands of type 'System.String' and 'System.String'.",
e.Message);
}
try
{
parser.Parse<object>("1 + 2 + 'abc' - 'abc' > 0").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 15:
... - 'abc' > 0 ...
^--- Operator '-' cannot be applied to operands of type 'System.String' and 'System.String'.",
e.Message);
}
try
{
parser.Parse<object>(
@"1 - 2
- (6 / ((2*'1.5' - 1) + 1)) * -2
+ 1/2/1 == 3.50").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 2, column 15:
... *'1.5' - 1) + 1)) * -2 ...
^--- Operator '*' cannot be applied to operands of type 'System.Int32' and 'System.String'.",
e.Message);
}
try
{
parser.Parse<object>(
@"1 - 2
- 6
+ 1/x/1 == 3.50").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 3, column 9:
... x/1 == 3.50 ...
^--- Only public properties, constants and enums are accepted. Identifier 'x' not known.",
e.Message);
}
try
{
parser.Parse<object>("WriteLine('hello')").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 1:
... WriteLine('hello') ...
^--- Function 'WriteLine' not known.",
e.Message);
}
try
{
parser.Parse<object>("Max(1.1)").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 1:
... Max(1.1) ...
^--- Function 'Max' accepting 1 argument not found.",
e.Message);
}
try
{
parser.Parse<object>("Max(1.1, 1.2, 'a')").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 1:
... Max(1.1, 1.2, 'a') ...
^--- Function 'Max' accepting 3 arguments not found.",
e.Message);
}
try
{
parser.Parse<object>(
@"Max(1,
Max(1, 'a')) == 1.1").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 2, column 14:
... 'a')) == 1.1 ...
^--- Function 'Max' 2nd argument implicit conversion from 'System.String' to expected 'System.Int32' failed.",
e.Message);
}
try
{
parser.Parse<object>("Now() && Today()").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 7:
... && Today() ...
^--- Operator '&&' cannot be applied to operands of type 'System.DateTime' and 'System.DateTime'.",
e.Message);
}
try
{
parser.Parse<object>("'a' >= 'b'").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 5:
... >= 'b' ...
^--- Operator '>=' cannot be applied to operands of type 'System.String' and 'System.String'.",
e.Message);
}
try
{
parser.Parse<object>("!'a'").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 1:
... !'a' ...
^--- Operator '!' cannot be applied to operand of type 'System.String'.",
e.Message);
}
try
{
parser.Parse<object>("!! Today()").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 2:
... ! Today() ...
^--- Operator '!' cannot be applied to operand of type 'System.DateTime'.",
e.Message);
}
try
{
parser.Parse<object>("0 == '0'").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 3:
... == '0' ...
^--- Operator '==' cannot be applied to operands of type 'System.Int32' and 'System.String'.",
e.Message);
}
try
{
parser.Parse<object>("0.1 != '0'").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 5:
... != '0' ...
^--- Operator '!=' cannot be applied to operands of type 'System.Double' and 'System.String'.",
e.Message);
}
try
{
parser.Parse<object>("'asd' > null").Invoke(null);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 7:
... > null ...
^--- Operator '>' cannot be applied to operands of type 'System.String' and 'null'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("Date + Date").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... + Date ...
^--- Operator '+' cannot be applied to operands of type 'System.DateTime' and 'System.DateTime'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("NDate + NDate").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 7:
... + NDate ...
^--- Operator '+' cannot be applied to operands of type 'System.Nullable`1[System.DateTime]' and 'System.Nullable`1[System.DateTime]'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("Date + NDate").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... + NDate ...
^--- Operator '+' cannot be applied to operands of type 'System.DateTime' and 'System.Nullable`1[System.DateTime]'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("Date == 0").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... == 0 ...
^--- Operator '==' cannot be applied to operands of type 'System.DateTime' and 'System.Int32'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("Date != 'asd'").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... != 'asd' ...
^--- Operator '!=' cannot be applied to operands of type 'System.DateTime' and 'System.String'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("Date > 0").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... > 0 ...
^--- Operator '>' cannot be applied to operands of type 'System.DateTime' and 'System.Int32'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("Date > null").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... > null ...
^--- Operator '>' cannot be applied to operands of type 'System.DateTime' and 'null'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("Date > SubModelObject").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... > SubModelObject ...
^--- Operator '>' cannot be applied to operands of type 'System.DateTime' and 'System.Object'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("NDate > SubModelObject").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 7:
... > SubModelObject ...
^--- Operator '>' cannot be applied to operands of type 'System.Nullable`1[System.DateTime]' and 'System.Object'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("NDate > null").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 7:
... > null ...
^--- Operator '>' cannot be applied to operands of type 'System.Nullable`1[System.DateTime]' and 'null'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("NDate != 'asd'").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 7:
... != 'asd' ...
^--- Operator '!=' cannot be applied to operands of type 'System.Nullable`1[System.DateTime]' and 'System.String'.",
e.Message);
}
try
{
var bag = new Bag {Lexer = new Lexer(), Parser = new Parser()};
parser.Parse<Bag>("Lexer != Parser").Invoke(bag);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 7:
... != Parser ...
^--- Operator '!=' cannot be applied to operands of type 'ExpressiveAnnotations.Analysis.Lexer' and 'ExpressiveAnnotations.Analysis.Parser'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("SubModelObject > SubModelObject").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 16:
... > SubModelObject ...
^--- Operator '>' cannot be applied to operands of type 'System.Object' and 'System.Object'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("null > null").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... > null ...
^--- Operator '>' cannot be applied to operands of type 'null' and 'null'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("null + null").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... + null ...
^--- Operator '+' cannot be applied to operands of type 'null' and 'null'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("null - null").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... - null ...
^--- Operator '-' cannot be applied to operands of type 'null' and 'null'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("'asd' - null").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 7:
... - null ...
^--- Operator '-' cannot be applied to operands of type 'System.String' and 'null'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("null / null").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... / null ...
^--- Operator '/' cannot be applied to operands of type 'null' and 'null'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("null && null").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... && null ...
^--- Operator '&&' cannot be applied to operands of type 'null' and 'null'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("null || null").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... || null ...
^--- Operator '||' cannot be applied to operands of type 'null' and 'null'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("null == 0").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... == 0 ...
^--- Operator '==' cannot be applied to operands of type 'null' and 'System.Int32'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("null < 0").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... < 0 ...
^--- Operator '<' cannot be applied to operands of type 'null' and 'System.Int32'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("Cash == null").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... == null ...
^--- Operator '==' cannot be applied to operands of type 'System.Decimal' and 'null'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("Date + 0").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... + 0 ...
^--- Operator '+' cannot be applied to operands of type 'System.DateTime' and 'System.Int32'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("NDate - 0").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 7:
... - 0 ...
^--- Operator '-' cannot be applied to operands of type 'System.Nullable`1[System.DateTime]' and 'System.Int32'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("Span + 0").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 6:
... + 0 ...
^--- Operator '+' cannot be applied to operands of type 'System.TimeSpan' and 'System.Int32'.",
e.Message);
}
try
{
var model = new Model();
parser.Parse<Model>("NSpan - 0").Invoke(model);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException);
Assert.AreEqual(
@"Parse error on line 1, column 7:
... - 0 ...
^--- Operator '-' cannot be applied to operands of type 'System.Nullable`1[System.TimeSpan]' and 'System.Int32'.",
e.Message);
}
}
/// <summary>
/// Registers built-in methods for expressions parser.
/// </summary>
/// <param name="parser">The parser instance.</param>
public static void RegisterMethods(this Parser parser)
{
parser.AddFunction("Now", () => DateTime.Now);
parser.AddFunction("Today", () => DateTime.Today);
parser.AddFunction <int, int, int, DateTime>("Date", (year, month, day) => new DateTime(year, month, day));
parser.AddFunction <int, int, int, int, int, int, DateTime>("Date", (year, month, day, hour, minute, second) => new DateTime(year, month, day, hour, minute, second));
parser.AddFunction <int, int, int, int, TimeSpan>("TimeSpan", (days, hours, minutes, seconds) => new TimeSpan(days, hours, minutes, seconds));
parser.AddFunction <string, int>("Length", str => str != null ? str.Length : 0);
parser.AddFunction <string, string>("Trim", str => str != null ? str.Trim() : null);
parser.AddFunction <string, string, string>("Concat", (strA, strB) => string.Concat(strA, strB));
parser.AddFunction <string, string, string, string>("Concat", (strA, strB, strC) => string.Concat(strA, strB, strC));
parser.AddFunction <string, string, int>("CompareOrdinal", (strA, strB) => string.Compare(strA, strB, StringComparison.Ordinal) > 0 ? 1 : string.Compare(strA, strB, StringComparison.Ordinal) < 0 ? -1 : 0);
parser.AddFunction <string, string, int>("CompareOrdinalIgnoreCase", (strA, strB) => string.Compare(strA, strB, StringComparison.OrdinalIgnoreCase) > 0 ? 1 : string.Compare(strA, strB, StringComparison.OrdinalIgnoreCase) < 0 ? -1 : 0);
parser.AddFunction <string, string, bool>("StartsWith", (str, prefix) => str != null && prefix != null && str.StartsWith(prefix));
parser.AddFunction <string, string, bool>("StartsWithIgnoreCase", (str, prefix) => str != null && prefix != null && str.StartsWith(prefix, StringComparison.OrdinalIgnoreCase));
parser.AddFunction <string, string, bool>("EndsWith", (str, suffix) => str != null && suffix != null && str.EndsWith(suffix));
parser.AddFunction <string, string, bool>("EndsWithIgnoreCase", (str, suffix) => str != null && suffix != null && str.EndsWith(suffix, StringComparison.OrdinalIgnoreCase));
parser.AddFunction <string, string, bool>("Contains", (str, substr) => str != null && substr != null && str.Contains(substr));
parser.AddFunction <string, string, bool>("ContainsIgnoreCase", (str, substr) => str != null && substr != null && str.ToLower().Contains(substr.ToLower()));
parser.AddFunction <string, bool>("IsNullOrWhiteSpace", str => string.IsNullOrWhiteSpace(str));
parser.AddFunction <string, bool>("IsDigitChain", str => str != null && Regex.IsMatch(str, @"^[0-9]+$"));
parser.AddFunction <string, bool>("IsNumber", str => str != null && Regex.IsMatch(str, @"^[+-]?(?:(?:[0-9]+)|(?:[0-9]+[eE][+-]?[0-9]+)|(?:[0-9]*\.[0-9]+(?:[eE][+-]?[0-9]+)?))$")); // +/- lexer float
parser.AddFunction <string, bool>("IsEmail", str => str != null && Regex.IsMatch(str, @"^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$")); // taken from HTML5 specification: http://www.w3.org/TR/html5/forms.html#e-mail-state-(type=email)
parser.AddFunction <string, bool>("IsUrl", str => str != null && Regex.IsMatch(str, @"^(?:(?:https?|ftp):\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)(?:\.(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)*(?:\.(?:[a-z\u00a1-\uffff]{2,})))(?::\d{2,5})?(?:\/\S*)?$", RegexOptions.IgnoreCase)); // contributed by Diego Perini: https://gist.github.com/dperini/729294 (https://mathiasbynens.be/demo/url-regex)
parser.AddFunction <string, string, bool>("IsRegexMatch", (str, regex) => str != null && regex != null && Regex.IsMatch(str, regex));
parser.AddFunction <string, Guid>("Guid", str => new Guid(str));
}
public static string Newton(string sfx, string sfdx, string sfddx, double a, double b, out int count)
{
Parser fx = new Parser(sfx);
fx.AddFunction<Algorithms>("log");
fx.Compile();
Parser fdx = new Parser(sfdx);
fdx.AddFunction<Algorithms>("log");
fdx.Compile();
Parser fddx = new Parser(sfddx);
fddx.AddFunction<Algorithms>("log");
fdx.Compile();
fx.Variables["x"] = a;
fddx.Variables["x"] = a;
double a_fpt = fx.Calculate() * fddx.Calculate();
fx.Variables["x"] = b;
fddx.Variables["x"] = b;
fx.Compile();
double b_fpt = fx.Calculate() * fddx.Calculate();
double fixedPoint = a_fpt > 0 ? a : b;
fx.Variables["x"] = fixedPoint;
fdx.Variables["x"] = fixedPoint;
double xn = fixedPoint - fx.Calculate()/fdx.Calculate();
count = 0;
while ((xn - fixedPoint) > eps)
{
fixedPoint = xn;
fx.Variables["x"] = xn;
fdx.Variables["x"] = xn;
xn = fixedPoint - fx.Calculate() / fdx.Calculate();
++count;
}
return xn.ToString();
}