conflict resolution

Author: Sébastien Geiser

CodingSeb.ExpressionEvaluator.Tests/ExpressionEvaluatorTests.cs

@@ -1402,15 +1402,29 @@ public static IEnumerable<TestCaseData> TestCasesForExceptionThrowingEvaluation
 
                 #region On the fly pre events cancel
 
-                evaluator = new ExpressionEvaluator();
+                evaluator = new ExpressionEvaluator(new Dictionary<string, object>
+                {
+                    { "P1var", "P1" },
+                    { "myObj", new ClassForTest1() },
+                });
 
                 evaluator.PreEvaluateVariable += (sender, e) =>
                 {
                     if (e.Name.StartsWith("P"))
                         e.CancelEvaluation = true;
                 };
 
+                evaluator.PreEvaluateFunction += (sender, e) =>
+                {
+                    if (e.Name.StartsWith("A"))
+                        e.CancelEvaluation = true;
+                };
+
                 yield return new TestCaseData(evaluator, "Pi", typeof(ExpressionEvaluatorSyntaxErrorException)).SetCategory("OnTheFly canceled Var");
+                yield return new TestCaseData(evaluator, "P1var", typeof(ExpressionEvaluatorSyntaxErrorException)).SetCategory("OnTheFly canceled Var");
+                yield return new TestCaseData(evaluator, "myObj.PropertyThatWillFailed", typeof(ExpressionEvaluatorSyntaxErrorException)).SetCategory("OnTheFly canceled Var");
+                yield return new TestCaseData(evaluator, "myObj.Add3To(5)", typeof(ExpressionEvaluatorSyntaxErrorException)).SetCategory("OnTheFly canceled Func");
+                yield return new TestCaseData(evaluator, "Abs(-5)", typeof(ExpressionEvaluatorSyntaxErrorException)).SetCategory("OnTheFly canceled Func");
 
                 #endregion
             }
@@ -1565,14 +1579,20 @@ public static IEnumerable<TestCaseData> TestCasesEvaluateWithSpecificEvaluator
 
                 #region Onthefly events (Pre events and/or Generics and/or Static)
 
-                ExpressionEvaluator evaluatorOnTheFlies = new ExpressionEvaluator();
+                ExpressionEvaluator evaluatorOnTheFlyGenericTypes = new ExpressionEvaluator(new Dictionary<string, object>
+                {
+                    { "myvar1", 10 },
+                    { "myvar2", 3 },
+                });
 
                 evaluatorOnTheFlies.Namespaces.Add("CodingSeb.ExpressionEvaluator.Tests");
 
                 void VariableEval(object sender, VariableEvaluationEventArg e)
                 {
-                    if(e.Name.Equals("GetSpecifiedGenericTypesVar"))
+                    if (e.Name.Equals("GetSpecifiedGenericTypesVar"))
                         e.Value = e.EvaluateGenericTypes();
+                    else if (e.Name.Equals("myvar2"))
+                        e.Value = 50;
                     else if (e.This is ClassOrTypeName classOrTypeName && classOrTypeName.Type == typeof(ClassForTest1) && e.Name.Equals("OnTheFlyStaticVar"))
                     {
                         e.Value = 10;
@@ -1665,6 +1685,16 @@ void Evaluator_PreEvaluateVariable(object sender, VariablePreEvaluationEventArg
                         .SetCategory("On the fly var")
                         .SetCategory("Static Onthefly");
 
+                yield return new TestCaseData(evaluatorOnTheFlyGenericTypes
+                        , "myvar1")
+                        .Returns(5)
+                        .SetCategory("var evaluation priority");
+
+                yield return new TestCaseData(evaluatorOnTheFlyGenericTypes
+                        , "myvar2")
+                        .Returns(3)
+                        .SetCategory("var evaluation priority");
+
                 yield return new TestCaseData(evaluatorOnTheFlies
                         , "ClassForTest1.OnTheFlyStaticPreFunc()")
                         .Returns(5)
@@ -1678,6 +1708,15 @@ void Evaluator_PreEvaluateVariable(object sender, VariablePreEvaluationEventArg
                         .SetCategory("Static Onthefly");
 
                 #endregion
+
+                #region bug resolution
+
+                yield return new TestCaseData(new ExpressionEvaluator()
+                    , "(new List<Regex>()).GetType()")
+                    .Returns(typeof(List<Regex>))
+                    .SetCategory("Bug resolution");
+
+                #endregion
             }
         }
 

CodingSeb.ExpressionEvaluator.Tests/TestsUtils/ClassForTest1.cs

@@ -12,6 +12,8 @@ public class ClassForTest1
 
         public static int StaticIntProperty { get; set; } = 67;
 
+        public int PropertyThatWillFailed { get; set; } = 1;
+
         public int Add3To(int value)
         {
             return value + 3;

CodingSeb.ExpressionEvaluator/ExpressionEvaluator.cs

@@ -1,6 +1,6 @@
 /******************************************************************************************************
     Title : ExpressionEvaluator (https://github.com/codingseb/ExpressionEvaluator)
-    Version : 1.3.7.1 
+    Version : 1.3.7.2 
     (if last digit (the forth) is not a zero, the version is an intermediate version and can be unstable)
 
     Author : Coding Seb
@@ -2120,7 +2120,6 @@ private bool EvaluateVarOrFunc(string expr, string restOfExpression, Stack<objec
                             stack.Push(varValueToPush);
                         }
                         else if ((Variables.TryGetValue(varFuncName, out object cusVarValueToPush) || varFuncMatch.Groups["assignationOperator"].Success)
-                            && !varFuncMatch.Groups["inObject"].Success
                             && (cusVarValueToPush == null || !TypesToBlock.Contains(cusVarValueToPush.GetType())))
                         {
                             stack.Push(cusVarValueToPush);
@@ -3090,7 +3089,7 @@ private Type GetTypeByFriendlyName(string typeName, string genericTypes = "", bo
                     if (!genericTypes.Equals(string.Empty))
                     {
                         Type[] types = GetConcreteTypes(genericTypes);
-                        formatedGenericTypes = $"`{types.Length}[{ string.Join(", ", types.Select(type => type.FullName))}]";
+                        formatedGenericTypes = $"`{types.Length}[{ string.Join(", ", types.Select(type => "[" + type.AssemblyQualifiedName + "]"))}]";
                     }
 
                     result = Type.GetType(typeName + formatedGenericTypes, false, !OptionCaseSensitiveEvaluationActive);