上传代码

alielie

2026-09-10 9ec80cafc23f5ee3278cacce3c9f86f4087b435a

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
using System;
using DynamicExpresso.Exceptions;
using NUnit.Framework;
 
namespace DynamicExpresso.UnitTest
{
    [TestFixture]
    public class GenerateDelegatesTest
    {
        [Test]
        public void Parse_To_a_Delegate()
        {
            var target = new Interpreter();
 
            var func = target.ParseAsDelegate<Func<double, double, double>>("Math.Pow(x, y) + 5", "x", "y");
 
            Assert.That(func(10, 2), Is.EqualTo(Math.Pow(10, 2) + 5));
 
            func = target.ParseAsDelegate<Func<double, double, double>>("Math.Pow(x, y) + .5", "x", "y");
            Assert.That(func(10, 2), Is.EqualTo(Math.Pow(10, 2) + .5));
        }
 
        [Test]
        public void Parse_To_a_Delegate_With_No_Parameters()
        {
            var target = new Interpreter();
 
            var func = target.ParseAsDelegate<Func<int>>("50");
 
            Assert.That(func(), Is.EqualTo(50));
        }
 
        [Test]
        public void Parse_To_a_Delegate_With_One_Parameter()
        {
            var target = new Interpreter();
 
            var func = target.ParseAsDelegate<Func<string, int>>("arg.Length");
 
            Assert.That(func("ciao"), Is.EqualTo(4));
            Assert.That(func("123456879"), Is.EqualTo(9));
        }
 
        [Test]
        public void Parse_To_a_Delegate_With_One_Parameter_With_Custom_Name()
        {
            var target = new Interpreter();
 
            var argumentName = "val"; // if not specified the delegate parameter is used which is "arg"
            var func = target.ParseAsDelegate<Func<string, int>>("val.Length", argumentName);
 
            Assert.That(func("ciao"), Is.EqualTo(4));
            Assert.That(func("123456879"), Is.EqualTo(9));
        }
 
        [Test]
        public void Parse_To_a_Delegate_With_Two_Parameters()
        {
            var target = new Interpreter();
 
            var func = target.ParseAsDelegate<Func<double, double, double>>("arg1 * arg2");
 
            Assert.That(func(3, 2), Is.EqualTo(6));
            Assert.That(func(5, 10), Is.EqualTo(50));
        }
 
        [Test]
        public void Parse_To_a_Delegate_With_Two_Parameters_With_Custom_Name()
        {
            var target = new Interpreter();
 
            var argumentNames = new [] { "x", "y" };
            var func = target.ParseAsDelegate<Func<double, double, double>>("x * y", argumentNames);
 
            Assert.That(func(3, 2), Is.EqualTo(6));
            Assert.That(func(5, 10), Is.EqualTo(50));
        }
 
        [Test]
        public void Parse_To_a_Custom_Delegate()
        {
            var target = new Interpreter();
 
            var func = target.ParseAsDelegate<MyCustomDelegate>("x + y.Length");
 
            Assert.That(func(3, "ciao"), Is.EqualTo(7));
            Assert.That(func(5, "mondo"), Is.EqualTo(10));
        }
 
        private delegate int MyCustomDelegate(int x, string y);
 
        [Test]
        public void Return_Type_Mismatch_Cause_An_Exception()
        {
            var target = new Interpreter();
 
            // expected a double but I return a string
            Assert.Throws<ParseException>(() => target.ParseAsDelegate<Func<double>>("\"ciao\""));
        }
    }
}