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));