public void ParseInteger()
{
var parser = new Core.Parser();
var constantExpression = parser.Parse("100") as ConstantExpression;
Assert.NotNull(constantExpression);
Assert.Equal("100", constantExpression.Raw);
Assert.Equal(100, constantExpression.Value);
constantExpression = parser.Parse("12312381") as ConstantExpression;
Assert.NotNull(constantExpression);
Assert.Equal("12312381", constantExpression.Raw);
Assert.Equal(12312381, constantExpression.Value);
constantExpression = parser.Parse("956869218") as ConstantExpression;
Assert.NotNull(constantExpression);
Assert.Equal("956869218", constantExpression.Raw);
Assert.Equal(956869218, constantExpression.Value);
var option = ParseOption.CreateOption()
.NotAllowedConvertUnsignedInteger()
.AsReadOnly();
constantExpression = parser.Parse("956869218", option) as ConstantExpression;
Assert.NotNull(constantExpression);
Assert.Equal("956869218", constantExpression.Raw);
Assert.NotEqual(956869218, constantExpression.Value);
Assert.Equal(956869218UL, constantExpression.Value);
}
public void TestCustomUnaryOperator()
{
var parser = new Core.Parser();
var compiler = Core.Compiler.Default;
var option = ParseOption.CreateOption()
.AddLiteralValue("compiler", compiler)
.AddUnaryOperator("@", s => s != null)
.AddUnaryOperator("not", s => s != null).AsReadOnly();
foreach (var item in new[] { "1", "2.0", "true", "'aa'", "compiler" })
{
Assert.Equal(false, compiler.Compile($"!{item}".ToEvaluableExpression(option)).Evaluate(null));
}
foreach (var item in new[] { "0", "-2.0", "false", "''", "null" })
{
Assert.Equal(true, compiler.Compile($"!{item}".ToEvaluableExpression(option)).Evaluate(null));
}
var array = new object[] { 'a', (sbyte)1, (byte)2, (ushort)3, (short)5, 66, (uint)4, 88L, (ulong)222, 6.0f, 7.0222d, 8.7232718m };
for (var i = 0; i < array.Length; i++)
{
var expr = $"!this[{i}]";
Assert.Equal(false, compiler.Compile(expr.ToEvaluableExpression()).Evaluate(array));
Assert.Equal(true, $"@this[{i}]".Compile(option).Evaluate(array));
Assert.Equal(true, $"not(this[{i}])".Compile(option).Evaluate(array));
}
array = new object[] { char.MinValue, sbyte.MinValue, (byte)0, (ushort)0, (short)-5, -66, (uint)0, long.MinValue, (ulong)0, -6.0f, -7.0222d, -8.7232718m };
for (var i = 0; i < array.Length; i++)
{
var expr = $"!this[{i}]";
Assert.Equal(true, expr.Compile(parser, compiler).Evaluate(array));
}
}
public void ParseNakedFunction()
{
var option = ParseOption.CreateOption()
.AddNakedFunction("abc", args => "abc")
.AddNakedFunction("hash", args => args.GetHashCode())
.AsReadOnly();
var parser = new Core.Parser();
var callExpression = parser.Parse("abc(1)", option) as NakedFunctionCallExpression;
Assert.NotNull(callExpression);
Assert.Equal("abc", callExpression.NakedFunction.Name);
callExpression = parser.Parse("max(1,2,3)", option) as NakedFunctionCallExpression;
Assert.NotNull(callExpression);
Assert.Equal("max", callExpression.NakedFunction.Name);
callExpression = parser.Parse("abc(hash(1,2,3))", option) as NakedFunctionCallExpression;
Assert.NotNull(callExpression);
Assert.Equal("abc", callExpression.NakedFunction.Name);
callExpression = callExpression.Arguments[0] as NakedFunctionCallExpression;
Assert.NotNull(callExpression);
Assert.Equal("hash", callExpression.NakedFunction.Name);
}
public void CompileLiteral()
{
var array = new object[] { 'a', (sbyte)-1, (byte)2, (ushort)3, (short)-3, -4, (uint)4, -5L, (ulong)5, 6.0f, 7.0222d, 8.7232718m };
var option = ParseOption.CreateOption()
.AddLiteralValue("array", array)
.AddLiteralValue("abc", -90.44m)
.AsReadOnly();
Assert.Equal(array.Length, "len(array)".Compile(option).Evaluate(null));
Assert.Equal(array.Length, "array.Length".Compile(option).Evaluate(null));
Assert.Equal(97m, "max(array)".Compile(option).Evaluate(null));
Assert.Equal(-5m, "min(array)".Compile(option).Evaluate(null));
Assert.Equal(119.7454718m, "sum(array)".Compile(option).Evaluate(null));
Assert.Equal(-90.44m, "abc".Compile(option).Evaluate(null));
Assert.Null("null".Compile().Evaluate(null));
Assert.Null("null".Compile().Evaluate(12));
Assert.Null("null".Compile().EvaluateAs <object>());
Assert.Null("null".Compile().EvaluateAsType(typeof(object)));
Assert.True("true".Compile().EvaluateAs <bool>());
Assert.False("false".Compile().EvaluateAs <bool>());
option = ParseOption.CreateOption()
.AddLiteralValue("longValue1", 2147483649L)
.AddLiteralValue("longValue2", 2147483641L)
.AsReadOnly();
Assert.Equal(2147483649L, "longValue1".Compile(option).EvaluateAs <long>());
Assert.Equal(2147483641, "longValue2".Compile(option).EvaluateAs <int>());
Assert.Equal(2147483647, "2147483647".Compile().EvaluateAs <int>());
Assert.Equal(2147483646, "2147483646".Compile().EvaluateAs <int>());
Assert.Equal(4294967295, "4294967295".Compile().EvaluateAs <uint>());
Assert.Equal(4294967294, "4294967294".Compile().EvaluateAs <uint>());
}
public void CompileInExpression()
{
var compiler = Core.Compiler.Default;
var option = ParseOption.CreateOption()
.AddLiteralValue("compiler", compiler)
.AsReadOnly();
Assert.Throws <ArgumentNullException>(() => compiler.Compile(null));
var evaluator = "1 in (1, 2.0222 ,true,'das', false, null, compiler)".Compile(option);
Assert.Equal(true, evaluator.Evaluate(null));
evaluator = "2.0222 in (1, 2.0222 ,true,'das', false, null, compiler)".Compile(option);
Assert.Equal(true, evaluator.Evaluate(null));
evaluator = "true in (1, 2.0222 ,true, 'das', false, null, compiler)".Compile(option);
Assert.Equal(true, evaluator.Evaluate(null));
evaluator = "'das' in (1, 2.0222 ,true,'das', false, null, compiler)".Compile(option);
Assert.Equal(true, evaluator.Evaluate(null));
evaluator = "false in (1, 2.0222 ,true,'das', false, null, compiler)".Compile(option);
Assert.Equal(true, evaluator.Evaluate(null));
evaluator = "null in (1, 2.0222 ,true,'das', false, null, compiler)".Compile(option);
Assert.Equal(true, evaluator.Evaluate(null));
evaluator = "compiler in (1, 2.0222 ,true,'das', false, null, compiler)".Compile(option);
Assert.Equal(true, evaluator.Evaluate(null));
evaluator = "99 in (1, 2.0222 ,true,'das', false, null, compiler)".Compile(option);
Assert.Equal(false, evaluator.Evaluate(null));
}
public void CompileObjectMemberExpression()
{
var fixture = new Fixture()
{
x = 12,
y = "aaa",
a = "x",
c = () => "string"
};
Assert.Equal(fixture.a, "this.a".Compile().EvaluateAs <string>(fixture));
Assert.Equal(fixture.a, "this[thisIsA]".Compile(ParseOption.CreateOption()
.AddLiteralValue("thisIsA", "a")
.AsReadOnly()
).EvaluateAs <string>(fixture));
Assert.Equal("aa", "this.a()".Compile().EvaluateAs <string>(new Fixture {
a = new Func <string>(() => "aa")
}));
Assert.Equal("aa", "this.D()".Compile().EvaluateAs <string>(new Fixture {
D = new Func <string>(() => "aa")
}));
Assert.Equal("12122", "this.D".Compile().EvaluateAs <string>(new Fixture {
D = "12122"
}));
Assert.Equal(fixture.ToString(), "this.ToString()".Compile().EvaluateAs <string>(fixture));
Assert.Equal(fixture.c(), "this.c()".Compile().EvaluateAs <string>(fixture));
Assert.Equal(fixture.ToString(), "this.ToString()".Compile().EvaluateAsType(fixture, typeof(string)));
Assert.Throws <ParseException>(() => "ToString()".Compile().Evaluate(fixture));
Assert.Equal(3, "this.lengthOf('abc')".Compile().Evaluate(new { lengthOf = new Func <string, int>(s => s.Length) }));
Assert.Equal(fixture.GetString("abc"), "this.GetString('abc')".Compile().Evaluate(fixture));
Assert.Equal(fixture.Add(12), "this.Add(12)".Compile().Evaluate(fixture));
Assert.Equal(fixture.Add(12), "a.Add(12)".Compile().Evaluate(new { a = fixture }));
Assert.Equal("1111", "this.f[0]()".Compile().Evaluate(new { f = new object[] { new Func <string>(() => "1111") } }));
Assert.Equal(6, "('abc'+d).Length".Compile().Evaluate(new { d = "efg" }));
}
public void TestPositive()
{
var compiler = Core.Compiler.Default;
Assert.Equal(12, compiler.Compile("+12".ToEvaluableExpression()).Evaluate(null));
Assert.Equal(12.8m, compiler.Compile("+12.8".ToEvaluableExpression()).Evaluate(null));
var option = ParseOption.CreateOption()
.AddLiteralValue("compiler", compiler)
.AsReadOnly();
Assert.Throws <UnsupportedOperationException>(() => compiler.Compile("+compiler".ToEvaluableExpression(option)).Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => compiler.Compile("+'aa'".ToEvaluableExpression()).Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => compiler.Compile("+true".ToEvaluableExpression()).Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => compiler.Compile("+null".ToEvaluableExpression()).Evaluate(null));
var array = new object[] { 'a', (sbyte)-1, (byte)2, (ushort)3, (short)-3, -4, (uint)4, -5L, (ulong)222, 6.0f, 7.0222d, 8.7232718m };
for (var i = 0; i < array.Length; i++)
{
var value = array[i];
var expr = $"+this[{i}]";
Assert.Equal(value, compiler.Compile(expr.ToEvaluableExpression()).Evaluate(array));
}
}
public void TestNegative()
{
Assert.Equal(-12, "-12".Compile().Evaluate(null));
Assert.Equal(-12.8m, "-12.8".Compile().Evaluate(null));
var compiler = Core.Compiler.Default;
var option = ParseOption.CreateOption()
.AddLiteralValue("compiler", compiler)
.AsReadOnly();
Assert.Throws <UnsupportedOperationException>(() => "-compiler".Compile(option).Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "-'aa'".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "-true".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "-null".Compile().Evaluate(null));
var array = new object[] { 'a', (sbyte)-1, (byte)2, (ushort)3, (short)-3, -4, (uint)4, -5L, 6.0f, 7.0222d, 8.7232718m };
Assert.Equal(-97, compiler.Compile("-this[0]".ToEvaluableExpression()).Evaluate(array));
Assert.Equal(1, compiler.Compile("-this[1]".ToEvaluableExpression()).Evaluate(array));
Assert.Equal(-2, compiler.Compile("-this[2]".ToEvaluableExpression()).Evaluate(array));
Assert.Equal(-3, compiler.Compile("-this[3]".ToEvaluableExpression()).Evaluate(array));
Assert.Equal(3, compiler.Compile("-this[4]".ToEvaluableExpression()).Evaluate(array));
Assert.Equal(4, compiler.Compile("-this[5]".ToEvaluableExpression()).Evaluate(array));
Assert.Equal(-4L, compiler.Compile("-this[6]".ToEvaluableExpression()).Evaluate(array));
Assert.Equal(5L, compiler.Compile("-this[7]".ToEvaluableExpression()).Evaluate(array));
Assert.Equal(-6.0f, compiler.Compile("-this[8]".ToEvaluableExpression()).Evaluate(array));
Assert.Equal(-7.0222d, compiler.Compile("-this[9]".ToEvaluableExpression()).Evaluate(array));
Assert.Equal(-8.7232718m, compiler.Compile("-this[10]".ToEvaluableExpression()).Evaluate(array));
Assert.Throws <UnsupportedOperationException>(() => compiler.Compile("-a".ToEvaluableExpression()).Evaluate(new { a = (ulong)222 }));
}
public void CompileCustomFunction()
{
var option = ParseOption.CreateOption()
.AddNakedFunction("tell_me_the_cat_name", s => "tom", true)
.AddNakedFunction("tell_me_the_mouse_name", s => "jerry", true)
.AddBinaryOperator("and", (a, b) => $"{a} and {b}", 10)
.AddNakedFunction("answer_for_question", s => (s[0] as string).Replace("吗", "").Replace("?", "!"))
.AddBinaryOperator("is", (a, b) => string.Equals(a as string, b as string), 10)
.AddLiteralValue("cat", "cat")
.AddLiteralValue("mouse", "mouse")
.AddNakedFunction("tell_me_the_name_of", s =>
{
switch (s[0])
{
case "cat":
return("tom");
case "mouse":
return("jerry");
default:
return("i don't know");
}
}, true)
.AsReadOnly();
Assert.Equal("tom and jerry", "tell_me_the_cat_name() and tell_me_the_mouse_name()".Compile(option).EvaluateAs <string>());
Assert.Equal("tom and jerry", "tell_me_the_name_of(cat) and tell_me_the_name_of(mouse)".Compile(option).EvaluateAs <string>());
Assert.True("answer_for_question('在吗?') is '在!'".Compile(option).EvaluateAs <bool>());
Assert.True("answer_for_question('你好') is '你好'".Compile(option).EvaluateAs <bool>());
Assert.True("answer_for_question('能听懂汉语吗?') is '能听懂汉语!'".Compile(option).EvaluateAs <bool>());
Assert.True("answer_for_question('真的吗?') is '真的!'".Compile(option).EvaluateAs <bool>());
}
public void TestLess()
{
Assert.Equal(true, "11<12".Compile().Evaluate(null));
Assert.Equal(true, "11.7<12".Compile().Evaluate(null));
Assert.Equal(true, "12.7<13".Compile().Evaluate(null));
Assert.Equal(true, "12.7<13.1".Compile().Evaluate(null));
Assert.Equal(false, "12<12".Compile().Evaluate(null));
Assert.Equal(false, "12<12.0".Compile().Evaluate(null));
Assert.Equal(false, "12.0<12".Compile().Evaluate(null));
Assert.Equal(false, "12.7<12.7".Compile().Evaluate(null));
Assert.Equal(false, "12<11".Compile().Evaluate(null));
Assert.Equal(false, "12<11.0".Compile().Evaluate(null));
Assert.Equal(false, "12.7<11".Compile().Evaluate(null));
Assert.Equal(false, "12.7<11.7".Compile().Evaluate(null));
var compiler = Core.Compiler.Default;
var option = ParseOption.CreateOption()
.AddLiteralValue("compiler", compiler)
.AsReadOnly();
Assert.Throws <UnsupportedOperationException>(() => "compiler<134".Compile(option).Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "'aa'<34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "true<34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "null<34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "34<null".Compile().Evaluate(null));
}
public void TestGreaterEqual()
{
Assert.Equal(true, "12>=11".Compile().Evaluate(null));
Assert.Equal(true, "12>=11.7".Compile().Evaluate(null));
Assert.Equal(true, "12.7>=11".Compile().Evaluate(null));
Assert.Equal(true, "12.7>=11.1".Compile().Evaluate(null));
Assert.Equal(true, "12>=12".Compile().Evaluate(null));
Assert.Equal(true, "12>=12.0".Compile().Evaluate(null));
Assert.Equal(true, "12.0>=12".Compile().Evaluate(null));
Assert.Equal(true, "12.7>=12.7".Compile().Evaluate(null));
Assert.Equal(false, "11>=12".Compile().Evaluate(null));
Assert.Equal(false, "11.7>=12".Compile().Evaluate(null));
Assert.Equal(false, "12.7>=13".Compile().Evaluate(null));
Assert.Equal(false, "12.7>=13.1".Compile().Evaluate(null));
var compiler = Core.Compiler.Default;
var option = ParseOption.CreateOption()
.AddLiteralValue("compiler", compiler)
.AsReadOnly();
Assert.Throws <UnsupportedOperationException>(() => "compiler>=134".Compile(option).Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "'aa'>=34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "true>=34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "null>=34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "34>=null".Compile().Evaluate(null));
}
public void CompileArray()
{
var compiler = Core.Compiler.Default;
Assert.Throws <ArgumentNullException>(() => compiler.Compile(null));
var option = ParseOption.CreateOption()
.AddLiteralValue("compiler", compiler)
.AsReadOnly();
var evaluator = "[1, 2.0222, -9.7777, true,'das', false, null, compiler]".Compile(option);
var array = (object[])evaluator.Evaluate(null);
Assert.Equal(8, array.Length);
Assert.Equal(1, array[0]);
Assert.Equal(2.0222m, array[1]);
Assert.Equal(-9.7777m, array[2]);
Assert.Equal(true, array[3]);
Assert.Equal("das", array[4]);
Assert.Equal(false, array[5]);
Assert.Null(array[6]);
Assert.Equal(compiler, array[7]);
Assert.Equal(2, "this[1]".Compile().EvaluateAs <int>(new object[] { 1, 2, 3 }));
}
public void TestNotEqual()
{
Assert.Equal(true, "11!=12".Compile().Evaluate(null));
Assert.Equal(true, "11.7!=12".Compile().Evaluate(null));
Assert.Equal(true, "12.7!=113".Compile().Evaluate(null));
Assert.Equal(true, "12.7!=13.1".Compile().Evaluate(null));
Assert.Equal(true, "true!=false".Compile().Evaluate(null));
Assert.Equal(true, "'aa'!='ab'".Compile().Evaluate(null));
Assert.Equal(true, "'aa'!='Ab'".Compile().Evaluate(null));
Assert.Equal(false, "null!=null".Compile().Evaluate(null));
Assert.Equal(false, "12!=12".Compile().Evaluate(null));
Assert.Equal(false, "12!=12.0".Compile().Evaluate(null));
Assert.Equal(false, "12.0!=12".Compile().Evaluate(null));
Assert.Equal(false, "12.7!=12.7".Compile().Evaluate(null));
Assert.Equal(false, "true!=true".Compile().Evaluate(null));
Assert.Equal(false, "'aa'!='aa'".Compile().Evaluate(null));
var compiler = Core.Compiler.Default;
var option = ParseOption.CreateOption()
.AddLiteralValue("compiler", compiler)
.AsReadOnly();
Assert.Throws <UnsupportedOperationException>(() => "compiler!=134".Compile(option).Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "'aa'!=134".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "true!=134".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "null!=134".Compile().Evaluate(null));
}
public void ParseLiterals()
{
var parser = new Core.Parser();
var literalExpression = parser.Parse("true") as LiteralExpression;
Assert.NotNull(literalExpression);
Assert.True((bool)literalExpression.LiteralValue.Value);
literalExpression = parser.Parse("false") as LiteralExpression;
Assert.NotNull(literalExpression);
Assert.False((bool)literalExpression.LiteralValue.Value);
literalExpression = parser.Parse("null") as LiteralExpression;
Assert.NotNull(literalExpression);
Assert.Null(literalExpression.LiteralValue.Value);
var option = ParseOption.CreateOption()
.AddLiteralValue("longValue1", 2147483649L)
.AddLiteralValue("longValue2", 2147483641L)
.AsReadOnly();
literalExpression = parser.Parse("longValue1", option) as LiteralExpression;
Assert.NotNull(literalExpression);
Assert.Equal(2147483649L, literalExpression.LiteralValue.Value);
literalExpression = parser.Parse("longValue2", option) as LiteralExpression;
Assert.NotNull(literalExpression);
Assert.Equal(2147483641L, literalExpression.LiteralValue.Value);
}
public void CompileTrick()
{
var compiler = Core.Compiler.Default;
Assert.Equal(4, "('ab'+'cd').Length".ToEvaluableExpression().Compile().Evaluate(null));
Assert.Equal(4, "('ab'+'cd').Length".ToEvaluableExpression().Compile(compiler).Evaluate(null));
Assert.Equal(4, "this[v]['Length']".Compile(
ParseOption.CreateOption()
.AddLiteralValue("v", "y")
.AsReadOnly()
).Evaluate(new Fixture {
y = "abcd"
}));
Assert.Equal(4, "this[v]['Len'+'gth']".Compile(
ParseOption.CreateOption()
.AddLiteralValue("v", "y")
.AsReadOnly()
).Evaluate(new Fixture {
y = "abcd"
}));
Assert.Equal(4, "('ab'+'cd').Length".Compile().Evaluate(null));
Assert.Throws <UnsupportedObjectIndexerException>(() => "this[v]".Compile(
ParseOption.CreateOption()
.AddLiteralValue("v", compiler)
.AsReadOnly()
).Evaluate(new Fixture()));
}
public void CompileMultiLevelObjectMemberExpression()
{
var a = new A
{
b = new A.B
{
c = new A.B.C
{
d = new A.B.C.D
{
e = "this is e"
}
}
}
};
Assert.Equal("this is e", "b['c']['d']['e']".Compile <A>().Evaluate(a));
Assert.Equal("this is e", "b['c'][thisIsD]['e']".Compile <A>(
ParseOption.CreateOption()
.AddLiteralValue("thisIsD", "d")
.AsReadOnly()
).Evaluate(a));
Assert.Equal("this is e", "b.c.d.e".Compile <A>().Evaluate(a));
Assert.Equal("this is e", "this.b.c.d.e".Compile <A>().Evaluate(a));
Assert.Equal(a.b, "b".Compile <A>().Evaluate(a));
}
public void TestOr()
{
var compiler = Core.Compiler.Default;
var option = ParseOption.CreateOption()
.AddLiteralValue("compiler", compiler)
.AsReadOnly();
var trueValues = new[] { "1", "2.0", "true", "'aa'", "compiler" };
var falseValues = new[] { "0", "-2.0", "false", "''", "null" };
foreach (var item in trueValues)
{
foreach (var trueValue in trueValues)
{
Assert.Equal(true, $"{item}||{trueValue}".Compile(option).Evaluate(null));
}
foreach (var falseValue in falseValues)
{
Assert.Equal(true, $"{item}||{falseValue}".Compile(option).Evaluate(null));
}
}
foreach (var item in falseValues)
{
foreach (var trueValue in trueValues)
{
Assert.Equal(true, $"{item}||{trueValue}".Compile(option).Evaluate(null));
}
foreach (var falseValue in falseValues)
{
Assert.Equal(false, $"{item}||{falseValue}".Compile(option).Evaluate(null));
}
}
}
public void CompileTrick()
{
var compiler = Core.Compiler.Default;
Assert.Equal(4, "('ab'+'cd').Length".ToEvaluableExpression().Compile <Fixture>().Evaluate(null));
Assert.Equal(4, "('ab'+'cd').Length".ToEvaluableExpression().Compile <Fixture>(compiler).Evaluate(null));
Assert.Equal(4, "this[v?'y':'x'][len]".Compile <Fixture>(
ParseOption.CreateOption()
.AddLiteralValue("v", true)
.AddLiteralValue("len", "Length")
.AsReadOnly()
).Evaluate(new Fixture {
y = "abcd"
}));
Assert.Equal(4, "this[v]['Len'+'gth']".Compile <Fixture>(
ParseOption.CreateOption()
.AddLiteralValue("v", "y")
.AsReadOnly()
).Evaluate(new Fixture {
y = "abcd"
}));
Assert.Equal(4, "this['y'][v]".Compile <Fixture>(
ParseOption.CreateOption()
.AddLiteralValue("v", "Length")
.AsReadOnly()
).Evaluate(new Fixture {
y = "abcd"
}));
Assert.Equal(4, "this[v]['Length']".Compile <Fixture>(
ParseOption.CreateOption()
.AddLiteralValue("v", "y")
.AsReadOnly()
).Evaluate(new Fixture {
y = "abcd"
}));
Assert.Equal(4, "('ab'+'cd').Length".Compile <Fixture>().Evaluate(null));
Assert.Equal("aa", "this[v?'D':'D']()".Compile <Fixture>(
ParseOption.CreateOption()
.AddLiteralValue("v", true)
.AsReadOnly()
).EvaluateAs <Fixture, string>(new Fixture {
D = new Func <string>(() => "aa")
}));
Assert.Throws <UnsupportedObjectIndexerException>(() => "this[v]".Compile <Fixture>(
ParseOption.CreateOption()
.AddLiteralValue("v", compiler)
.AsReadOnly()
).Evaluate(new Fixture()));
}
public void CompileObjectMemberExpression()
{
Assert.Throws <ArgumentNullException>(() => Core.Compiler.Default.Compile <Fixture>(null));
var cachedEvaluator = "3*'abc'".Compile <Fixture>();
Assert.Equal("abcabcabc", cachedEvaluator.EvaluateAs <Fixture, string>(null));
Assert.Equal("abcabcabc", cachedEvaluator.EvaluateAs <Fixture, string>(null));
var fixture = new Fixture()
{
x = 12,
y = "aaa",
a = "x",
c = () => "string"
};
Assert.Equal(3, "abc".Compile <IndexerObject>().EvaluateAs <IndexerObject, int>(new IndexerObject()));
Assert.Equal(fixture.a, "this.a".Compile <Fixture>().EvaluateAs <Fixture, string>(fixture));
Assert.Equal(fixture.a, "this[thisIsA]".Compile <Fixture>(
ParseOption.CreateOption()
.AddLiteralValue("thisIsA", "a")
.AsReadOnly()
).EvaluateAs <Fixture, string>(fixture));
Assert.Equal("aa", "this.a()".Compile <Fixture>().EvaluateAs <Fixture, string>(new Fixture {
a = new Func <string>(() => "aa")
}));
Assert.Equal("aa", "this.D()".Compile <Fixture>().EvaluateAs <Fixture, string>(new Fixture {
D = new Func <string>(() => "aa")
}));
Assert.Equal("12122", "this.D".Compile <Fixture>().EvaluateAs <Fixture, string>(new Fixture {
D = "12122"
}));
Assert.Equal("12122", "D".Compile <Fixture>().EvaluateAs <Fixture, string>(new Fixture {
D = "12122"
}));
Assert.Equal(12122, "E".Compile <Fixture>().EvaluateAs <Fixture, int>(new Fixture {
E = 12122
}));
Assert.Equal("this is a value", "a".Compile <Fixture>().EvaluateAs <Fixture, string>(new Fixture {
a = "this is a value"
}));
Assert.Equal(123456, "x".Compile <Fixture>().EvaluateAs <Fixture, int>(new Fixture {
x = 123456
}));
Assert.Equal(fixture.ToString(), "this.ToString()".Compile <Fixture>().EvaluateAs <Fixture, string>(fixture));
Assert.Equal(fixture.c(), "this.c()".Compile <Fixture>().EvaluateAs <Fixture, string>(fixture));
Assert.Equal(fixture.c(), "this.c()".Compile <Fixture>(Core.Parser.Default).EvaluateAs <Fixture, string>(fixture));
Assert.Equal(fixture.ToString(), "this.ToString()".Compile <Fixture>().EvaluateAsType(fixture, typeof(string)));
Assert.Equal(fixture.GetString("abc"), "this.GetString('abc')".Compile <Fixture>().Evaluate(fixture));
Assert.Equal(fixture.Add(12), "this.Add(12)".Compile <Fixture>().Evaluate(fixture));
Assert.Equal(fixture.Add(12).ToString(), "this.Add(12)".Compile <Fixture>().EvaluateAs <Fixture, string>(fixture));
Assert.Null("this.DoSomething()".Compile <Fixture>().Evaluate(fixture));
Assert.Throws <MemberNotFoundException>(() => "Y".Compile <Fixture>().Evaluate(fixture));
Assert.Throws <MemberNotFoundException>(() => "this.Y".Compile <Fixture>().Evaluate(fixture));
}
public void CompileNakeStatisticsFunctions()
{
var compiler = new Core.Compiler();
Assert.Throws <ArgumentNullException>(() => compiler.Compile(null));
var option = ParseOption.CreateOption();
option.LiteralValues.Add(new LiteralValue("compiler", compiler));
Assert.Equal(4, compiler.Compile("len([1, 2.0222, true, 'das'])".ToEvaluableExpression()).Evaluate(null));
Assert.Equal(0, compiler.Compile("len([])".ToEvaluableExpression()).Evaluate(null));
Assert.Throws <UnsupportedFunctionCallException>(() => compiler.Compile("len()".ToEvaluableExpression()).Evaluate(null));
Assert.Throws <UnsupportedFunctionCallException>(() => compiler.Compile("len(1,8)".ToEvaluableExpression()).Evaluate(null));
Assert.Equal(11.5m, compiler.Compile("max([1, -2.0222, -89, 11.5])".ToEvaluableExpression()).Evaluate(null));
Assert.Equal(110m, compiler.Compile("max([1, 110, -89, 100])".ToEvaluableExpression()).Evaluate(null));
Assert.Throws <UnsupportedFunctionCallException>(() => compiler.Compile("max()".ToEvaluableExpression()).Evaluate(null));
Assert.Throws <UnsupportedFunctionCallException>(() => compiler.Compile("max(1,8)".ToEvaluableExpression()).Evaluate(null));
Assert.Throws <UnsupportedFunctionCallException>(() => compiler.Compile("max([1, 2.0222 ,true,'das', false, null, compiler])".ToEvaluableExpression(option.AsReadOnly())).Evaluate(null));
Assert.Equal(-89m, compiler.Compile("min([1, -2.0222, -89, 11.5])".ToEvaluableExpression()).Evaluate(null));
Assert.Equal(-90.1m, compiler.Compile("min([1, 110, -90.1, 100])".ToEvaluableExpression()).Evaluate(null));
Assert.Throws <UnsupportedFunctionCallException>(() => compiler.Compile("min()".ToEvaluableExpression()).Evaluate(null));
Assert.Throws <UnsupportedFunctionCallException>(() => compiler.Compile("min(1,8)".ToEvaluableExpression()).Evaluate(null));
Assert.Throws <UnsupportedFunctionCallException>(() => compiler.Compile("min([1, 2.0222 ,true,'das', false, null, compiler])".ToEvaluableExpression(option.AsReadOnly())).Evaluate(null));
var watch = Stopwatch.StartNew();
var evaluator = compiler.Compile($"sum([{string.Join(",", Enumerable.Range(1, 1000))}])".ToEvaluableExpression());
Assert.Equal((decimal)Enumerable.Range(1, 1000).Sum(), evaluator.Evaluate(null));
watch.Stop();
var elapsedTicks = watch.ElapsedTicks;
watch.Restart();
Assert.Equal((decimal)Enumerable.Range(1, 1000).Sum(), evaluator.Evaluate(null));
watch.Stop();
Assert.True(watch.ElapsedTicks < elapsedTicks);
Assert.Equal(5050m, compiler.Compile($"sum([{string.Join(",", Enumerable.Range(0, 101))}])".ToEvaluableExpression()).Evaluate(null));
Assert.Equal((decimal)Enumerable.Range(1, 1000).Sum(), compiler.Compile($"sum([{string.Join(",", Enumerable.Range(1, 1000))}])".ToEvaluableExpression()).Evaluate(null));
Assert.Throws <UnsupportedFunctionCallException>(() => compiler.Compile("sum()".ToEvaluableExpression()).Evaluate(null));
Assert.Throws <UnsupportedFunctionCallException>(() => compiler.Compile("sum(1,8)".ToEvaluableExpression()).Evaluate(null));
Assert.Throws <UnsupportedFunctionCallException>(() => compiler.Compile("sum([1, 2.0222 ,true,'das', false, null, compiler])".ToEvaluableExpression(option.AsReadOnly())).Evaluate(null));
Assert.Equal(50m, compiler.Compile($"avg([{string.Join(",", Enumerable.Range(0, 101))}])".ToEvaluableExpression()).Evaluate(null));
Assert.Throws <UnsupportedFunctionCallException>(() => compiler.Compile("avg()".ToEvaluableExpression()).Evaluate(null));
Assert.Throws <UnsupportedFunctionCallException>(() => compiler.Compile("avg(1,8)".ToEvaluableExpression()).Evaluate(null));
Assert.Throws <UnsupportedFunctionCallException>(() => compiler.Compile("avg([1, 2.0222 ,true,'das', false, null, compiler])".ToEvaluableExpression(option.AsReadOnly())).Evaluate(null));
}
public void TestModulo()
{
Assert.Equal(0, "22%2".Compile().Evaluate(null));
Assert.Equal(1m, "25%2.0".Compile().Evaluate(null));
Assert.Equal(0.222m, "28.222%2".Compile().Evaluate(null));
Assert.Equal(0.21m, "36.21%3.0".Compile().Evaluate(null));
var compiler = Core.Compiler.Default;
var option = ParseOption.CreateOption()
.AddLiteralValue("compiler", compiler)
.AsReadOnly();
Assert.Throws <UnsupportedOperationException>(() => "compiler%134".Compile(option).Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "'aa'%34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "false%34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "34%null".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "null%34".Compile().Evaluate(null));
}
public void TestMinus()
{
Assert.Equal(1, "12-11".Compile().Evaluate(null));
Assert.Equal(.9m, "12-11.1".Compile().Evaluate(null));
Assert.Equal(1.8009m, "12.8009-11".Compile().Evaluate(null));
Assert.Equal(1.0009m, "12.8009-11.8".Compile().Evaluate(null));
var compiler = Core.Compiler.Default;
var option = ParseOption.CreateOption()
.AddLiteralValue("compiler", compiler)
.AsReadOnly();
Assert.Throws <UnsupportedOperationException>(() => "compiler-134".Compile(option).Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "false-34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "'a'-34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "34-null".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "null-34".Compile().Evaluate(null));
}
public void Setup()
{
var option = ParseOption.CreateOption();
var expr = "0";
for (var i = 0; i < FunctionCount; i++)
{
var name = $"f{i}";
var value = i;
option.AddNakedFunction(name, s => value, Cacheable);
total += value;
expr = $"{expr}+{name}()";
}
evaluator = expr.Compile(option.AsReadOnly());
if (WarmUp)
{
evaluator.EvaluateAs <decimal>();
}
}
public void Setup()
{
var option = ParseOption.CreateOption();
var expr = "0";
for (var i = 0; i < LiteralCount; i++)
{
var name = $"v{i}";
var value = i;
total += value;
expr = $"{expr}+{name}";
option.AddLiteralValue(name, value);
}
evaluator = expr.Compile(option.AsReadOnly());
if (WarmUp)
{
evaluator.EvaluateAs <decimal>();
}
}
public void TestDivide()
{
Assert.Equal(2, "22/11".Compile().Evaluate(null));
Assert.Equal(12.5m, "25/2.0".Compile().Evaluate(null));
Assert.Equal(14.111m, "28.222/2".Compile().Evaluate(null));
Assert.Equal(12.07m, "36.21/3.0".Compile().Evaluate(null));
var compiler = Core.Compiler.Default;
var option = ParseOption.CreateOption()
.AddLiteralValue("compiler", compiler)
.AsReadOnly();
Assert.Throws <UnsupportedOperationException>(() => "compiler/134".Compile(option).Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "'aa'/34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "null/34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "false/34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "34/null".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "null/34".Compile().Evaluate(null));
}
public void TestMultiply()
{
Assert.Equal(12 * 11, "12*11".Compile().Evaluate(null));
Assert.Equal(133.2m, "12*11.1".Compile().Evaluate(null));
Assert.Equal(140.8099m, "12.8009*11".Compile().Evaluate(null));
Assert.Equal(151.05062m, "12.8009*11.8".Compile().Evaluate(null));
Assert.Equal("ababab", "3*'ab'".Compile().Evaluate(null));
Assert.Equal("ababab", "'ab'*3".Compile().Evaluate(null));
var compiler = Core.Compiler.Default;
var option = ParseOption.CreateOption()
.AddLiteralValue("compiler", compiler)
.AsReadOnly();
Assert.Throws <UnsupportedOperationException>(() => "compiler*134".Compile(option).Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "null*34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "false*34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "34*null".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "null*34".Compile().Evaluate(null));
}
public void NotAllowedInExpression()
{
var option = ParseOption.CreateOption()
.NotAllowedInExpression()
.AsReadOnly();
var parser = new Core.Parser();
Assert.Equal("In expression is not allowed at character 5", Assert.Throws <ParseException>(() => parser.Parse("1 in (1,2,3)", option)).Message);
Assert.Equal("In expression is not allowed at character 6", Assert.Throws <ParseException>(() => parser.Parse("xy in (m['u'],n,y)", option)).Message);
Assert.NotNull(parser.Parse("[1,2,3]", option) as ArrayExpression);
Assert.NotNull(parser.Parse("true?1:2", option) as ConditionalExpression);
Assert.NotNull(parser.Parse("x.f", option) as ObjectMemberExpression);
Assert.NotNull(parser.Parse("x['f']", option) as ObjectMemberExpression);
var add = parser.Parse("add", option) as IdentifierExpression;
Assert.NotNull(add);
Assert.Equal("add", add.Name);
Assert.NotNull(parser.Parse("12", option) as ConstantExpression);
}
public void TestAdd()
{
Assert.Equal(46, "12+34".Compile().Evaluate(null));
Assert.Equal(888888888 + 12, "12+888888888".Compile().Evaluate(null));
Assert.Equal(8888888888 + 12UL, "12+8888888888".Compile().Evaluate(null));
Assert.Equal(24.7m, "12+12.7".Compile().Evaluate(null));
Assert.Equal(46.7m, "12.7+34".Compile().Evaluate(null));
Assert.Equal(25.1m, "12.4+12.7".Compile().Evaluate(null));
Assert.Equal("abc", "'a'+'bc'".Compile().Evaluate(null));
var compiler = Core.Compiler.Default;
var option = ParseOption.CreateOption()
.AddLiteralValue("compiler", compiler)
.AsReadOnly();
Assert.Throws <UnsupportedOperationException>(() => "compiler+134".Compile(option).Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "true+34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "'a'+34".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "34+null".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "null+34".Compile().Evaluate(null));
}
public void CompileConditionalExpression()
{
var parser = new Core.Parser();
var compiler = Core.Compiler.Default;
var option = ParseOption.CreateOption()
.AddLiteralValue("compiler", compiler)
.AsReadOnly();
var trueValues = new[] { "1", "2.0", "true", "'aa'", "compiler" };
var falseValues = new[] { "0", "-2.0", "false", "''", "null" };
foreach (var item in trueValues)
{
var expr = $"{item}?true:false";
Assert.Equal(true, expr.Compile(parser, option).Evaluate(null));
}
foreach (var item in falseValues)
{
var expr = $"{item}?true:false";
Assert.Equal(false, expr.Compile(parser, option, compiler).Evaluate(null));
}
}
public void TestEqual()
{
Assert.Equal(false, "11==12".Compile().Evaluate(null));
Assert.Equal(false, "11.7==12".Compile().Evaluate(null));
Assert.Equal(false, "12.7==113".Compile().Evaluate(null));
Assert.Equal(false, "12.7==13.1".Compile().Evaluate(null));
Assert.Equal(false, "true==false".Compile().Evaluate(null));
Assert.Equal(false, "'aa'=='ab'".Compile().Evaluate(null));
Assert.Equal(false, "'aa'=='Ab'".Compile().Evaluate(null));
Assert.Equal(true, "null==null".Compile().Evaluate(null));
Assert.Equal(true, "12==12".Compile().Evaluate(null));
Assert.Equal(true, "12==12.0".Compile().Evaluate(null));
Assert.Equal(true, "12.0==12".Compile().Evaluate(null));
Assert.Equal(true, "12.7==12.7".Compile().Evaluate(null));
Assert.Equal(true, "true==true".Compile().Evaluate(null));
Assert.Equal(true, "'aa'=='aa'".Compile().Evaluate(null));
var compiler = Core.Compiler.Default;
var option = ParseOption.CreateOption()
.AddLiteralValue("compiler", compiler)
.AsReadOnly();
Assert.Throws <UnsupportedOperationException>(() => "compiler==134".Compile(option).Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "'aa'==134".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "true==134".Compile().Evaluate(null));
Assert.Throws <UnsupportedOperationException>(() => "null==134".Compile().Evaluate(null));
var array = new object[] { 'a', (sbyte)97, (byte)97, (ushort)97, (short)97, 97, (uint)97, 97L, (ulong)97, 97f, 97d, 97m };
for (var i = 0; i < array.Length; i++)
{
for (var j = 0; j < array.Length; j++)
{
var expr = $"this[{i}]==this[{j}]";
Assert.Equal(true, expr.Compile().Evaluate(array));
}
}
}
