/// <summary>
        /// Execute a function call two times with different values.
        ///
        /// fct(a)  a:=8  ->return false
        /// fct(a)  a:=12  ->return true
        ///
        /// </summary>
        public static void CallFunctionWithIntParam_TwoTimes()
        {
            string expr = "fct(a)";

            Console.WriteLine("\n====The expression is: " + expr);

            ExpressionEval evaluator = new ExpressionEval();

            //====1/decode the expression
            evaluator.Parse(expr);

            //====2/prepare the execution, attach function
            Console.WriteLine("Attach function code to Fct() and set value to param: a=8");
            evaluator.DefineVarInt("a", 8);
            evaluator.AttachFunction("fct", FctRetBool_Int);

            //====3/Execute the expression
            ExecResult execResult = evaluator.Exec();

            //====4/get the result, its a bool value
            Console.WriteLine("Execution Result (should return false): " + execResult.ResultBool);

            //============================================================
            //====2/prepare the execution, attach function
            Console.WriteLine("Set value to param: a=12");
            evaluator.DefineVarInt("a", 12);
            evaluator.AttachFunction("fct", FctRetBool_Int);

            //====3/Execute the expression
            execResult = evaluator.Exec();

            //====4/get the result, its a bool value
            Console.WriteLine("Execution Result (should return true): " + execResult.ResultBool);
        }
Ejemplo n.º 2
0
        public void fct_OP_CP_retBool_false_ok()
        {
            ExpressionEval evaluator = new ExpressionEval();

            // definir langue: fr ou en, sert pour les opérateurs: ET/AND, OU/OR, NON/NOT.
            evaluator.SetLang(Language.En);

            string      expr        = "fct()";
            ParseResult parseResult = evaluator.Parse(expr);

            //====2/prepare the execution, provide all used variables: type and value
            //ExprExecResult execResult = evaluator.InitExec();

            // attach the function code FctFalse() to the function call: Fct()
            evaluator.AttachFunction("Fct", FctFalse);

            //====3/execute l'expression booléenne
            ExecResult execResult = evaluator.Exec();

            Assert.AreEqual(false, execResult.HasError, "The exec of the expression should finish with success");

            // check the final result value (is ExprExecFunctionCallBool override ExprExecValueBool)
            ExprExecValueBool valueBool = execResult.ExprExec as ExprExecValueBool;

            Assert.IsNotNull(execResult, "The result value should be a bool");
            Assert.AreEqual(false, valueBool.Value, "The result value should be: false");
        }
Ejemplo n.º 3
0
        public void fct_OP_CP_retBool_paramMissing_ok()
        {
            ExpressionEval evaluator = new ExpressionEval();

            // definir langue: fr ou en, sert pour les opérateurs: ET/AND, OU/OR, NON/NOT.
            evaluator.SetLang(Language.En);

            string      expr        = "fct()";
            ParseResult parseResult = evaluator.Parse(expr);

            //====2/prepare the execution, provide all used variables: type and value
            //ExprExecResult execResult = evaluator.InitExec();

            // link function body to function call
            evaluator.AttachFunction("fct", FctRetBool_P1Bool);

            //====3/execute l'expression booléenne
            ExecResult execResult = evaluator.Exec();

            Assert.IsTrue(execResult.HasError, "The exec of the expression should finish with error");

            Assert.AreEqual(ErrorCode.FunctionCallParamCountWrong, execResult.ListError[0].Code, "The exec of the expression should finish with success");
            Assert.AreEqual("FunctionCallName", execResult.ListError[0].ListErrorParam[0].Key, "The exec of the expression should finish with success");
            Assert.AreEqual("fct", execResult.ListError[0].ListErrorParam[0].Value, "The exec of the expression should finish with success");
        }
        public void fct_OP_12_Sep_bonjour_8dot5_CP_retInt_21_ok()
        {
            ExpressionEval evaluator = new ExpressionEval();

            // definir langue: fr ou en, sert pour les opérateurs: ET/AND, OU/OR, NON/NOT.
            evaluator.SetLang(Language.En);

            string expr = "fct(4, \"bonjour\", 8.5)";

            evaluator.Parse(expr);

            // link function body to function call
            var funcMapper = new Func3ParamsRetIntMapper <int, string, double>();

            funcMapper.SetFunction(FctP1Int_P2String_P3Double);
            evaluator.AttachFunction("Fct", funcMapper);

            //====3/execute l'expression booléenne
            ExecResult execResult = evaluator.Exec();

            Assert.AreEqual(false, execResult.HasError, "The exec of the expression should finish with success");

            // check the final result value (is ExprExecFunctionCallBool override ExprExecValueBool)
            ExprExecValueInt valueInt = execResult.ExprExec as ExprExecValueInt;

            Assert.IsNotNull(execResult, "The result value should be a bool");
            Assert.AreEqual(21, valueInt.Value, "The result value should be: 18");
        }
Ejemplo n.º 5
0
        public void fct_OP_a_CP_retDouble_P1String_ok()
        {
            ExpressionEval evaluator = new ExpressionEval();

            // definir langue: fr ou en, sert pour les opérateurs: ET/AND, OU/OR, NON/NOT.
            evaluator.SetLang(Language.En);

            string      expr        = "fct(a)";
            ParseResult parseResult = evaluator.Parse(expr);

            //====2/prepare the execution, provide all used variables: type and value
            //ExprExecResult execResult = evaluator.InitExec();

            // 3 letters -> return 3x1.5=4.5
            evaluator.DefineVarString("a", "abc");

            // link function body to function call
            evaluator.AttachFunction("Fct", FctDouble_String);

            //====3/execute l'expression booléenne
            ExecResult execResult = evaluator.Exec();

            Assert.AreEqual(false, execResult.HasError, "The exec of the expression should finish with success");

            // check the final result value (is ExprExecFunctionCallBool override ExprExecValueBool)
            ExprExecValueDouble valueDouble = execResult.ExprExec as ExprExecValueDouble;

            Assert.IsNotNull(valueDouble, "The result value should be a double");
            Assert.AreEqual(4.5, valueDouble.Value, "The result value should be: true");
        }
Ejemplo n.º 6
0
        public void fct_3Params_FunctionCall_OneMissing_err()
        {
            ExpressionEval evaluator = new ExpressionEval();

            // definir langue: fr ou en, sert pour les opérateurs: ET/AND, OU/OR, NON/NOT.
            evaluator.SetLang(Language.En);

            string expr = "fct(true, true)";

            evaluator.Parse(expr);

            // link function body to function call
            Func3ParamsRetBoolMapper <bool, bool, bool> func3ParamsRetBoolMapper = new Pierlam.ExpressionEval.Func3ParamsRetBoolMapper <bool, bool, bool>();

            func3ParamsRetBoolMapper.SetFunction(Fct3ParamsBool);
            evaluator.AttachFunction("fct", func3ParamsRetBoolMapper);

            //====3/execute l'expression booléenne
            ExecResult execResult = evaluator.Exec();

            Assert.IsTrue(execResult.HasError, "The exec of the expression should finish with error");

            Assert.AreEqual(ErrorCode.FunctionCallParamCountWrong, execResult.ListError[0].Code, "The exec of the expression should finish with success");
            Assert.AreEqual("FunctionCallName", execResult.ListError[0].ListErrorParam[0].Key, "The exec of the expression should finish with success");
            Assert.AreEqual("fct", execResult.ListError[0].ListErrorParam[0].Value, "The exec of the expression should finish with success");
        }
        public void fct_OP_false_Sep_false_CP_retBool_true_ok()
        {
            ExpressionEval evaluator = new ExpressionEval();

            // definir langue: fr ou en, sert pour les opérateurs: ET/AND, OU/OR, NON/NOT.
            evaluator.SetLang(Language.En);

            string expr = "fct(true, true, true)";

            evaluator.Parse(expr);

            // link function body to function call
            var funcMapper = new Func3ParamsRetBoolMapper <bool, bool, bool>();

            funcMapper.SetFunction(Fct3ParamsBool);
            evaluator.AttachFunction("Fct", funcMapper);

            //====3/execute l'expression booléenne
            ExecResult execResult = evaluator.Exec();

            Assert.AreEqual(false, execResult.HasError, "The exec of the expression should finish with success");

            // check the final result value (is ExprExecFunctionCallBool override ExprExecValueBool)
            ExprExecValueBool valueBool = execResult.ExprExec as ExprExecValueBool;

            Assert.IsNotNull(execResult, "The result value should be a bool");
            Assert.AreEqual(true, valueBool.Value, "The result value should be: true");
        }
        public void fct_OP_10_Sep_bonjour_CP_retBool_true_ok()
        {
            ExpressionEval evaluator = new ExpressionEval();

            // definir langue: fr ou en, sert pour les opérateurs: ET/AND, OU/OR, NON/NOT.
            evaluator.SetLang(Language.En);
            evaluator.SetStringTagCode(StringTagCode.Quote);

            string expr = "fct(10, 'bonjour')";

            evaluator.Parse(expr);

            // link function body to function call
            evaluator.AttachFunction("Fct", FctP1Int_P2String);

            //====3/execute l'expression booléenne
            ExecResult execResult = evaluator.Exec();

            Assert.AreEqual(false, execResult.HasError, "The exec of the expression should finish with success");

            // check the final result value (is ExprExecFunctionCallBool override ExprExecValueBool)
            ExprExecValueBool valueBool = execResult.ExprExec as ExprExecValueBool;

            Assert.IsNotNull(execResult, "The result value should be a bool");
            Assert.AreEqual(true, valueBool.Value, "The result value should be: true");
        }
        /// <summary>
        /// Execute a function having 2 int parameters.
        /// </summary>
        public static void CallFunctionWith3IntParams_ret_10()
        {
            string expr = "fct(a,b,c)";

            Console.WriteLine("\n====The expression is: " + expr);

            ExpressionEval evaluator = new ExpressionEval();

            //====1/decode the expression
            evaluator.Parse(expr);

            //====2/prepare the execution, attach function
            Console.WriteLine("Attach function code to Fct() and set value to param: a=2, b=3; c=5");
            evaluator.DefineVarInt("a", 2);
            evaluator.DefineVarInt("b", 3);
            evaluator.DefineVarInt("c", 5);

            // attach the 3 params function to the function call
            Func3ParamsRetIntMapper <int, int, int> func3ParamsRetIntMapper = new Func3ParamsRetIntMapper <int, int, int>();

            func3ParamsRetIntMapper.SetFunction(FctRetInt_Int_Int_Int);
            evaluator.AttachFunction("fct", func3ParamsRetIntMapper);

            //====3/Execute the expression
            ExecResult execResult = evaluator.Exec();

            //====4/get the result, its a bool value
            Console.WriteLine("Execution has error? (should be false): " + execResult.HasError);
            Console.WriteLine("Execution Result is an int type?: " + execResult.IsResultInt);
            Console.WriteLine("Execution Result is (should be 10): " + execResult.ResultInt);
        }
Ejemplo n.º 10
0
        public void fct_OP_not_OP_a_CP_CP_retBool_true_ok()
        {
            ExpressionEval evaluator = new ExpressionEval();

            // definir langue: fr ou en, sert pour les opérateurs: ET/AND, OU/OR, NON/NOT.
            evaluator.SetLang(Language.En);

            string      expr        = "fct(not (a))";
            ParseResult parseResult = evaluator.Parse(expr);

            //====2/prepare the execution, provide all used variables and functions
            evaluator.DefineVarBool("a", true);

            // link function body to function call
            evaluator.AttachFunction("Fct", Fct_RetNot);

            //====3/execute l'expression booléenne
            ExecResult execResult = evaluator.Exec();

            Assert.AreEqual(false, execResult.HasError, "The exec of the expression should finish with success");

            // check the final result value (is ExprExecFunctionCallBool override ExprExecValueBool)
            ExprExecValueBool valueBool = execResult.ExprExec as ExprExecValueBool;

            Assert.IsNotNull(execResult, "The result value should be a bool");
            Assert.AreEqual(true, valueBool.Value, "The result value should be: true");
        }
        /// <summary>
        /// Use a function call in the expression.
        /// A function code is attached to the function call and executed.
        /// </summary>
        public static void Fct_OP_CP_true()
        {
            string expr = "fct()";

            Console.WriteLine("\n====The expression is: " + expr);

            ExpressionEval evaluator = new ExpressionEval();

            //====1/decode the expression
            evaluator.Parse(expr);

            //====2/prepare the execution, attach function
            Console.WriteLine("Attach function code to Fct():");
            evaluator.AttachFunction("fct", FctRetBool);

            //====3/Execute the expression
            ExecResult execResult = evaluator.Exec();

            //====4/get the result, its a bool value
            Console.WriteLine("Execution Result: " + execResult.ResultBool);
        }
        public void functionCall_paramTypeWrong_err()
        {
            ExpressionEval evaluator = new ExpressionEval();

            // definir langue: fr ou en, sert pour les opérateurs: ET/AND, OU/OR, NON/NOT.
            evaluator.SetLang(Language.En);
            evaluator.SetStringTagCode(StringTagCode.Quote);

            string expr = "fct('bonjour')";

            evaluator.Parse(expr);

            // link function body to function call
            evaluator.AttachFunction("Fct", FctInt);

            //====3/execute l'expression booléenne
            ExecResult execResult = evaluator.Exec();

            Assert.IsTrue(execResult.HasError, "The exec of the expression should finish with error");

            Assert.AreEqual(ErrorCode.FunctionCallParamTypeWrong, execResult.ListError[0].Code, "The exec of the expression should finish with error");
        }
Ejemplo n.º 13
0
        public void fct_OP_not_12_CP_retBool_true_ok()
        {
            ExpressionEval evaluator = new ExpressionEval();

            // definir langue: fr ou en, sert pour les opérateurs: ET/AND, OU/OR, NON/NOT.
            evaluator.SetLang(Language.En);

            string      expr        = "fct(not 12)";
            ParseResult parseResult = evaluator.Parse(expr);

            //====2/prepare the execution, provide all used variables and functions

            // link function body to function call
            evaluator.AttachFunction("Fct", Fct_RetNot);

            //====3/execute l'expression booléenne
            ExecResult execResult = evaluator.Exec();

            Assert.AreEqual(true, execResult.HasError, "The exec of the expression should finish with success");

            Assert.AreEqual(ErrorCode.ExprLogicalNotOperator_InnerOperandBoolTypeExpected, execResult.ListError[0].Code, "The exec of the expression should finish with error: ExprLogicalNotOperator_InnerOperandBoolTypeExpected");
        }
Ejemplo n.º 14
0
        public void fct_OP_CP_FuncCallNotExists_err()
        {
            ExpressionEval evaluator = new ExpressionEval();

            // definir langue: fr ou en, sert pour les opérateurs: ET/AND, OU/OR, NON/NOT.
            evaluator.SetLang(Language.En);

            string      expr        = "fct()";
            ParseResult parseResult = evaluator.Parse(expr);

            //====2/prepare the execution, provide all used variables: type and value
            //ExprExecResult execResult = evaluator.InitExec();

            // link the function code FctFalse() to the function call: Fct()
            evaluator.AttachFunction("FctDoesnotExist", FctFalse);

            //====3/execute l'expression booléenne
            ExecResult execResult = evaluator.Exec();

            // an error occurs
            Assert.IsTrue(execResult.HasError, "The exec of the expression should failed");

            Assert.AreEqual(ErrorCode.FunctionCallNotLinked, execResult.ListError[0].Code, "The error code should be xx");
        }
        /// <summary>
        /// Execute a function having 2 int parameters.
        /// </summary>
        public static void CallFunctionWith2IntParams_ret_5()
        {
            string expr = "fct(a,b)";

            Console.WriteLine("\n====The expression is: " + expr);

            ExpressionEval evaluator = new ExpressionEval();

            //====1/decode the expression
            evaluator.Parse(expr);

            //====2/prepare the execution, attach function
            Console.WriteLine("Attach function code to Fct() and set value to param: a=8");
            evaluator.DefineVarInt("a", 2);
            evaluator.DefineVarInt("b", 3);
            evaluator.AttachFunction("fct", FctRetInt_Int_Int);

            //====3/Execute the expression
            ExecResult execResult = evaluator.Exec();

            //====4/get the result, its a bool value
            Console.WriteLine("Execution Result is an int type?: " + execResult.IsResultInt);
            Console.WriteLine("Execution Result is (should be 5): " + execResult.ResultInt);
        }