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 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));
}
}
}
public void ParseOptionCollectionOperate()
{
var values = new ParseOption().LiteralValues;
Assert.False(values.IsReadOnly);
Parallel.For(0, 100, i =>
{
var value = new LiteralValue($"p{i}", i);
values.Add(value);
Assert.True(values.Contains(value));
if (i % 2 == 0)
{
values.Remove(value);
Assert.False(values.Contains(value));
}
});
Assert.Equal(50, values.Count);
Assert.True(values.Skip(10).Take(10).Count(x => (int)(x.Value) % 2 == 0) == 0);
var copies = new LiteralValue[70];
values.CopyTo(copies, 10);
Assert.True(copies.Take(10).Count(x => x == null) == 10);
Assert.True(copies.Skip(10).Take(50).Count(x => x != null) == 50);
Assert.True(copies.Skip(60).Take(10).Count(x => x == null) == 10);
IEnumerable enumerator = values;
foreach (var item in enumerator)
{
Assert.True((int)((item as LiteralValue)?.Value ?? 0) % 2 != 0);
}
Parallel.For(0, 100, i => values.Clear());
Assert.Equal(0, values.Count);
}
public static ParseOption AddNakedFunction(this ParseOption option, NakedFunction function)
{
option.NakedFunctions.Add(function);
return(option);
}
public static void RegisterExecutor <T>(string element, ParseOption options = ParseOption.None) where T : SaveExecutor, new() => RegisterExecutor(typeof(T), element, options);
//public static byte[] ImageToByteArray(Image imageIn)
//{
// using (var ms = new MemoryStream())
// {
// imageIn.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
// return ms.ToArray();
// }
//}
public static string ParseTrxData(string trxName, ParseOption option)
{
trxName = Path.GetFileNameWithoutExtension(trxName);
string result = string.Empty;
if (option == ParseOption.Version)
{
Regex pattern = new Regex(@"B[0-9]\.\d\.\d+");
result = pattern.Match(trxName).Value;
}
else if (option == ParseOption.TestResult)
{
Regex pattern = new Regex(@"\d+-\d+-\d+-\d+$");
result = pattern.Match(trxName).Value;
}
else if (option == ParseOption.NameOfTest)
{
Regex pattern = new Regex(@"^([^\""]*)_[Desktop, Mobile]");
string matche = pattern.Match(trxName).Value;
//Kastbil, real shit
result = matche.Substring(0, matche.Length - 2);
}
else if (option == ParseOption.Browser)
{
List <string> BrowserTypes = ConfigurationManager.AppSettings["SupportedBrowsers"]
.Split(',', ' ')
.Where(x => !string.IsNullOrWhiteSpace(x))
.ToList();
foreach (var browser in BrowserTypes)
{
if (trxName.Contains("_" + browser + "_"))
{
result = browser;
break;
}
}
}
else if (option == ParseOption.Theme)
{
List <string> Themes = ConfigurationManager.AppSettings["SupportedThemes"]
.Split(',', ' ')
.Where(x => !string.IsNullOrWhiteSpace(x))
.ToList();
foreach (var theme in Themes)
{
if (trxName.Contains("_" + theme + "_"))
{
result = theme;
break;
}
}
}
else if (option == ParseOption.DataBase)
{
List <string> DataBases = ConfigurationManager.AppSettings["SupportedDataBases"]
.Split(',', ' ')
.Where(x => !string.IsNullOrWhiteSpace(x))
.ToList();
foreach (var database in DataBases)
{
if (trxName.Contains("_" + database + "_"))
{
result = database;
break;
}
}
}
return(result);
}
public void ParseBinaryExpression()
{
var parser = new Core.Parser();
var binaryExpression = parser.Parse("12+34+true") as BinaryExpression;
Assert.NotNull(binaryExpression);
Assert.Equal("+", binaryExpression.BinaryOperator.Operator);
Assert.Equal(true, (binaryExpression.Right as LiteralExpression)?.LiteralValue.Value);
Assert.Equal(0, binaryExpression.StartIndex);
Assert.Equal(10, binaryExpression.EndIndex);
var left = binaryExpression.Left as BinaryExpression;
Assert.NotNull(left);
Assert.Equal("+", left.BinaryOperator.Operator);
Assert.Equal(12, (left.Left as ConstantExpression)?.Value);
Assert.Equal(34, (left.Right as ConstantExpression)?.Value);
binaryExpression = parser.Parse("12*34+true") as BinaryExpression;
Assert.NotNull(binaryExpression);
Assert.Equal("+", binaryExpression.BinaryOperator.Operator);
Assert.Equal(true, (binaryExpression.Right as LiteralExpression)?.LiteralValue.Value);
left = binaryExpression.Left as BinaryExpression;
Assert.NotNull(left);
Assert.Equal("*", left.BinaryOperator.Operator);
Assert.Equal(12, (left.Left as ConstantExpression)?.Value);
Assert.Equal(34, (left.Right as ConstantExpression)?.Value);
binaryExpression = parser.Parse("(12*34+true)||(false)") as BinaryExpression;
Assert.NotNull(binaryExpression);
Assert.Equal("||", binaryExpression.BinaryOperator.Operator);
Assert.Equal(false, (binaryExpression.Right as LiteralExpression)?.LiteralValue.Value);
left = binaryExpression.Left as BinaryExpression;
Assert.NotNull(left);
Assert.Equal("+", left.BinaryOperator.Operator);
Assert.Equal(true, (left.Right as LiteralExpression)?.LiteralValue.Value);
var right = left.Left as BinaryExpression;
Assert.NotNull(right);
Assert.Equal("*", right.BinaryOperator.Operator);
Assert.Equal(12, (right.Left as ConstantExpression)?.Value);
Assert.Equal(34, (right.Right as ConstantExpression)?.Value);
binaryExpression = parser.Parse("12 + 19") as BinaryExpression;
Assert.NotNull(binaryExpression);
Assert.Equal("+", binaryExpression.BinaryOperator.Operator);
Assert.Equal(12, (binaryExpression.Left as ConstantExpression)?.Value);
Assert.Equal(19, (binaryExpression.Right as ConstantExpression)?.Value);
var option = ParseOption.CreateOption()
.AddBinaryOperator("@", (a, b) => null, 8)
.AsReadOnly();
binaryExpression = parser.Parse("12 @ true", option) as BinaryExpression;
Assert.NotNull(binaryExpression);
Assert.Equal("@", binaryExpression.BinaryOperator.Operator);
Assert.Equal(12, (binaryExpression.Left as ConstantExpression)?.Value);
Assert.Equal(true, (binaryExpression.Right as LiteralExpression)?.LiteralValue.Value);
option = ParseOption.CreateOption()
.AddBinaryOperator("add", (a, b) => null, 8)
.AsReadOnly();
var add = parser.Parse("12 add 34", option) as BinaryExpression;
Assert.NotNull(add);
Assert.Equal("add", add.BinaryOperator.Operator);
Assert.Equal(12, (add.Left as ConstantExpression)?.Value);
Assert.Equal(34, (add.Right as ConstantExpression)?.Value);
}
public static ParseOption NotAllowedConvertUnsignedInteger(this ParseOption option)
{
option.NotAllowedConvertUnsignedInteger = true;
return(option);
}
/// <summary>
/// Builds a new parser for the specified grammar and input using the supplied rules.
/// </summary>
/// <param name="grammar">The grammar to use.</param>
/// <param name="inputText">The input text to use.</param>
/// <param name="option">The parsing options to use.</param>
/// <returns>A new <see cref="Parser"/> instance.</returns>
/// <exception cref="GrammarException">No parser found for specified grammar.</exception>
/// <exception cref="ArgumentNullException"><paramref name="grammar"/> is <see langword="null" />.</exception>
/// <exception cref="ArgumentNullException"><paramref name="inputText"/> is <see langword="null" />.</exception>
public Parser BuildParserWithOptions([NotNull] GrammarReference grammar, [NotNull] string inputText, ParseOption option)
{
if (grammar is null)
{
throw new ArgumentNullException(nameof(grammar));
}
if (inputText is null)
{
throw new ArgumentNullException(nameof(inputText));
}
if (grammar.Parser == null)
{
throw new GrammarException($"No parser found for grammar \"{grammar.GrammarName}\"");
}
var loader = new Grammar.Loader();
var inputStream = new AntlrInputStream(inputText);
var lexer = loader.LoadLexer(grammar, inputStream);
var commonTokenStream = new CommonTokenStream(lexer);
commonTokenStream.Fill();
Tokens = commonTokenStream.GetTokens();
SyntaxTokens = ConvertTokensToSyntaxTokens(lexer, Tokens);
if (option.HasFlag(ParseOption.Tokens))
{
foreach (var token in Tokens)
{
Console.WriteLine(token.ToString());
}
}
var parser = loader.LoadParser(grammar, commonTokenStream);
// Handle Tree parsing option
parser.BuildParseTree = option.HasFlag(ParseOption.Tree);
// Handle Diagnostics parsing option
if (option.HasFlag(ParseOption.Diagnostics))
{
parser.AddErrorListener(new DiagnosticErrorListener());
parser.Interpreter.PredictionMode = Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection;
}
// Handle Sll parsing option
if (option.HasFlag(ParseOption.Sll))
{
parser.Interpreter.PredictionMode = Antlr4.Runtime.Atn.PredictionMode.Sll;
}
// Handle Trace parsing option
parser.Trace = option.HasFlag(ParseOption.Trace);
return(parser);
}
public static ParseOption AddUnaryOperator(this ParseOption option, string @operator, UnaryOperatorHandler handler) => option.AddUnaryOperator(new UnaryOperator(@operator, handler));
/// <inheritdoc />
public void Parse(GrammarReference grammar, string parserRuleName, string text, ParseOption options)
{
lock (_Padlock)
{
var nextRun = CalculateNextRunTime(_PreviousNodeQty, 50, 5, 1000);
var work = new ParserWorkItem(grammar, parserRuleName, text, options, nextRun);
QueuedWork.Enqueue(work);
_LastQueuedTime = DateTime.Now;
if (ParserTask.IsCompleted)
{
ParserTask = new Task(ParserWorkLoop);
}
if (ParserTask.Status != TaskStatus.Running)
{
ParserTask.Start();
}
}
}
public void CompileDictionary()
{
var compiler = Core.Compiler.Default;
Assert.Equal(222, "this[2]".Compile <Dictionary <int, int> >().Evaluate(new Dictionary <int, int>
{
[1] = 111,
[2] = 222
}));
Assert.Equal("b", "this[2]".Compile <Dictionary <int, object> >().Evaluate(new Dictionary <int, object>
{
[1] = "a",
[2] = "b"
}));
Assert.Equal("b", "this[1+1]".Compile <Dictionary <int, object> >().Evaluate(new Dictionary <int, object>
{
[1] = "a",
[2] = "b"
}));
Assert.Equal("b", "this[1+v]".Compile <Dictionary <int, object> >(
ParseOption.CreateOption()
.AddLiteralValue("v", 1)
.AsReadOnly()
).Evaluate(new Dictionary <int, object>
{
[1] = "a",
[2] = "b"
}));
Assert.Equal(2147483649L, "this[2]".Compile <Dictionary <int, object> >().Evaluate(new Dictionary <int, object>
{
[1] = "a",
[2] = 2147483649L
}));
Assert.Equal(compiler, "this['a']".Compile <Dictionary <string, object> >().Evaluate(new Dictionary <string, object>
{
["a"] = compiler,
["b"] = "b"
}));
Assert.Equal(compiler, "this.a".Compile <dynamic>().Evaluate(new
{
a = compiler,
b = "b"
}));
Assert.Equal(compiler, "this['a']".Compile <dynamic>().Evaluate(new
{
a = compiler,
b = "b"
}));
Assert.Equal(3428392, "this.b".Compile <Dictionary <string, int> >().Evaluate(new Dictionary <string, int>
{
["a"] = 456237,
["b"] = 3428392
}));
Assert.Equal(3428392, "b".Compile <Dictionary <string, int> >().Evaluate(new Dictionary <string, int>
{
["a"] = 456237,
["b"] = 3428392
}));
Assert.Equal(3428392, "b".Compile <Hashtable>().Evaluate(new Hashtable
{
["a"] = 456237,
["b"] = 3428392
}));
Assert.Equal(compiler, "a".Compile <Dictionary <string, object> >().Evaluate(new Dictionary <string, object>
{
["a"] = compiler,
["b"] = "b"
}));
Assert.Equal("aaa", "this.a()".Compile <Dictionary <string, object> >().Evaluate(new Dictionary <string, object>
{
["a"] = new Func <object>(() => "aaa"),
["b"] = "b"
}));
Assert.True("this.a(null)".Compile <Dictionary <string, object> >().EvaluateAs <Dictionary <string, object>, bool>(new Dictionary <string, object>
{
["a"] = new Func <object, object>(s => s == null),
["b"] = "b"
}));
Assert.Null("this.a(null)".Compile <Dictionary <string, Func <object, object> > >().EvaluateAs <Dictionary <string, Func <object, object> >, object>(new Dictionary <string, Func <object, object> > {
["a"] = Fixture.ReturnMe
}));
Assert.Null("this.b(null)".Compile <Dictionary <string, Func <object, object> > >().EvaluateAs <Dictionary <string, Func <object, object> >, object>(new Dictionary <string, Func <object, object> > {
["b"] = Fixture.ReturnMe
}));
Assert.Null("this.a(null)".Compile <Dictionary <string, Action> >().EvaluateAs <Dictionary <string, Action>, object>(new Dictionary <string, Action> {
["a"] = Fixture.DoEmpty
}));
Assert.Throws <UnsupportedFunctionException>(() => compiler.Compile <Dictionary <string, object> >("this.a('111')".ToEvaluableExpression())
.Evaluate(new Dictionary <string, object>
{
["a"] = "11".Compile().EvaluateAs <int>() == 11 ? (Func <string>)null : () => "emptyFunc"
}));
}
public MissionExecutorAttribute(string element, ParseOption parseOptions = ParseOption.None)
{
Element = element;
ParseOptions = parseOptions;
}
public static ParseOption AddBinaryOperator(this ParseOption option, BinaryOperator @operator)
{
option.BinaryOperators.Add(@operator);
return(option);
}
public ExtensionInfoExecutorAttribute(string element, ParseOption parseOptions = ParseOption.None)
{
Element = element;
ParseOptions = parseOptions;
}
public static ParseOption AddLiteralValue(this ParseOption option, string literal, object value) => option.AddLiteralValue(new LiteralValue(literal, value));
public static ParseOption AddLiteralValue(this ParseOption option, LiteralValue literalValue)
{
option.LiteralValues.Add(literalValue);
return(option);
}
public static ParseOption NotAllowedArrayExpression(this ParseOption option)
{
option.NotAllowedArrayExpression = true;
return(option);
}
public static ParseOption AddBinaryOperator(this ParseOption option, string @operator, BinaryOperatorHandler handler, uint precedence) => option.AddBinaryOperator(new BinaryOperator(@operator, handler, precedence));
public void ErrorExpression()
{
var parser = new Core.Parser();
Assert.Throws <ArgumentException>(() => parser.Parse(""));
Assert.Throws <ArgumentException>(() => parser.Parse(null));
Assert.Throws <ArgumentException>(() => parser.Parse(" "));
Assert.Equal("Unexpected \"#\" at character 0", Assert.Throws <ParseException>(() => parser.Parse("#aaa")).Message);
Assert.Equal("Unexpected \"@\" at character 0", Assert.Throws <ParseException>(() => parser.Parse("@aaa")).Message);
Assert.Equal("Unexpected \"@\" at character 4", Assert.Throws <ParseException>(() => parser.Parse("$aa @a)")).Message);
Assert.Equal("Unexpected \0 at character 2", Assert.Throws <ParseException>(() => parser.Parse("x.")).Message);
Assert.Equal("Unclosed ( at character 1", Assert.Throws <ParseException>(() => parser.Parse("(")).Message);
Assert.Equal("Expected ] at character 1", Assert.Throws <ParseException>(() => parser.Parse("[")).Message);
Assert.Equal("Expected ) at character 5", Assert.Throws <ParseException>(() => parser.Parse("x.f(a")).Message);
Assert.Equal("Unclosed ( at character 1", Assert.Throws <ParseException>(() => parser.Parse("(@11)")).Message);
Assert.Equal("Unclosed ( at character 1", Assert.Throws <ParseException>(() => parser.Parse("(#aa)")).Message);
Assert.Equal("Unclosed ( at character 5", Assert.Throws <ParseException>(() => parser.Parse("($aa @a)")).Message);
Assert.Equal("Unclosed [ at character 2", Assert.Throws <ParseException>(() => parser.Parse("x[")).Message);
Assert.Equal("Unclosed quote after \"\" at character 3", Assert.Throws <ParseException>(() => parser.Parse("x['")).Message);
Assert.Equal("Expected ] at character 6", Assert.Throws <ParseException>(() => parser.Parse("x.f([1")).Message);
Assert.Equal("Expected , at character 5", Assert.Throws <ParseException>(() => parser.Parse("x.f([)")).Message);
Assert.Equal("Unexpected token , at character 6", Assert.Throws <ParseException>(() => parser.Parse("max([,")).Message);
Assert.Equal("Unexpected token , at character 2", Assert.Throws <ParseException>(() => parser.Parse("[,,,]")).Message);
Assert.Equal("Unexpected token , at character 4", Assert.Throws <ParseException>(() => parser.Parse("[a,,]")).Message);
Assert.Equal("Expected , at character 6", Assert.Throws <ParseException>(() => parser.Parse("avg((),aa)")).Message);
Assert.Equal("Expected , at character 13", Assert.Throws <ParseException>(() => parser.Parse("avg([1,2,t,],#aa)")).Message);
Assert.Equal("Unexpected \"a\" at character 5", Assert.Throws <ParseException>(() => parser.Parse("a in aa")).Message);
Assert.Equal("Expected expression after % at character 2", Assert.Throws <ParseException>(() => parser.Parse("2%")).Message);
Assert.Equal("Variable names cannot start with a number (10a) at character 2", Assert.Throws <ParseException>(() => parser.Parse("10a")).Message);
Assert.Equal("Unexpected period at character 3", Assert.Throws <ParseException>(() => parser.Parse("10..")).Message);
Assert.Equal("Expected exponent (10e) at character 3", Assert.Throws <ParseException>(() => parser.Parse("10er")).Message);
Assert.Equal("Unclosed quote after \"abasdkas\" at character 9", Assert.Throws <ParseException>(() => parser.Parse("'abasdkas")).Message);
Assert.Equal("Unclosed quote after \"rualkl\" at character 7", Assert.Throws <ParseException>(() => parser.Parse("\"rualkl")).Message);
Assert.Equal("Unclosed quote after \"bm121\\u22a\" at character 11", Assert.Throws <ParseException>(() => parser.Parse("\"bm121\\u22a")).Message);
Assert.Equal("Unclosed quote after \"bm121\" at character 7", Assert.Throws <ParseException>(() => parser.Parse("\"bm121\\")).Message);
Assert.Equal("Expected expression at character 2", Assert.Throws <ParseException>(() => parser.Parse("x?")).Message);
Assert.Equal("Expected expression at character 2", Assert.Throws <ParseException>(() => parser.Parse("x?:")).Message);
Assert.Equal("Expected : at character 3", Assert.Throws <ParseException>(() => parser.Parse("x?p")).Message);
Assert.Equal("Expected expression at character 4", Assert.Throws <ParseException>(() => parser.Parse("x?p:")).Message);
Assert.Equal("Expected expression at character 2", Assert.Throws <ParseException>(() => parser.Parse("x?:p")).Message);
Assert.Equal("Expected expression at character 4", Assert.Throws <ParseException>(() => parser.Parse("x?p:")).Message);
Assert.Equal("Expected expression after + at character 2", Assert.Throws <ParseException>(() => parser.Parse("x+")).Message);
Assert.Equal("Expected expression after + at character 4", Assert.Throws <ParseException>(() => parser.Parse("xYY+")).Message);
Assert.Equal("Expected expression after * at character 4", Assert.Throws <ParseException>(() => parser.Parse("x+y*")).Message);
Assert.Equal("Unexpected token , at character 5", Assert.Throws <ParseException>(() => parser.Parse("avg(,aa)")).Message);
Assert.Equal("Unexpected token ) at character 9", Assert.Throws <ParseException>(() => parser.Parse("a[max(c,)]")).Message);
Assert.Equal("Can not find naked function (f) at character 0", Assert.Throws <ParseException>(() => parser.Parse("f(1,2)")).Message);
Assert.Equal("Can not find naked function (p) at character 2", Assert.Throws <ParseException>(() => parser.Parse("1+p(1,2)")).Message);
Assert.Equal("Can not parse value(111111111111111111111111) to ulong at (start:0,end:24)", Assert.Throws <InvalidCastException>(() => parser.Parse("111111111111111111111111")).Message);
Assert.Equal("Can not parse value(7792281625142643375935439503359228162514264337593543950335.11) to decimal at (start:0,end:61)", Assert.Throws <InvalidCastException>(() => parser.Parse("7792281625142643375935439503359228162514264337593543950335.11")).Message);
var option = ParseOption.CreateOption()
.AddBinaryOperator("add", (a, b) => null, 8)
.AddBinaryOperator("a@", (a, b) => null, 8)
.AsReadOnly();
Assert.Throws <ParseException>(() => parser.Parse("12 add ", option));
Assert.Throws <ParseException>(() => parser.Parse("12 a@", option));
}
public static ParseOption AddNakedFunction(this ParseOption option, string name, NakedFunctionHandler handler, bool cacheable = false) => option.AddNakedFunction(new NakedFunction(name, handler, cacheable));
