Mercurial > pub > bltoolkit

comparison UnitTests/CS/Aspects/OverloadAspectTest.cs @ 0:f990fcb411a9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Копия текущей версии из github
author cin
date Thu, 27 Mar 2014 21:46:09 +0400
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:f990fcb411a9
1 using System;
2
3 using NUnit.Framework;
4
5 using BLToolkit.Aspects;
6 using BLToolkit.Reflection;
7 using BLToolkit.TypeBuilder;
8
9 namespace Aspects
10 {
11 [TestFixture]
12 public class OverloadAspectTest
13 {
14 public abstract class TestObject<T>
15 {
16 public T Test(T inVal, out T outVal)
17 {
18 outVal = inVal;
19 return inVal;
20 }
21
22 public string Test(DateTime dateVal, string inVal)
23 {
24 return inVal.ToUpper();
25 }
26
27 [Overload] abstract public T Test(T inVal);
28 [Overload] abstract public T Test(T inVal, out T outVal, ref T refVal);
29 [Overload] abstract public T Test(T inVal, DateTime dateVal);
30 }
31
32 public abstract class TestObject
33 {
34 public int IntValue;
35 public string StrValue;
36 public Guid GuidValue;
37
38 public void Test(int intVal, Guid guidVal)
39 {
40 IntValue = intVal;
41 GuidValue = guidVal;
42 StrValue = "(default)";
43 }
44
45 public void Test(int intVal, string strVal)
46 {
47 IntValue = intVal;
48 StrValue = strVal;
49 GuidValue = Guid.Empty;
50 }
51
52 public void OutRefTest(int inVal, out int outVal, ref int refVal)
53 {
54 outVal = inVal;
55 refVal += inVal;
56 }
57
58 public void OutRefStructTest(int? inVal, out int? outVal, ref int? refVal)
59 {
60 outVal = inVal;
61 refVal += inVal;
62 }
63
64 protected static int StaticMethod(int intVal, ref Guid guidVal)
65 {
66 return intVal;
67 }
68
69 public T Generic<T>(T inVal, out T outVal)
70 {
71 outVal = inVal;
72 return inVal;
73 }
74
75 // Becomes
76 // public override void Test(Guid guidVal)
77 // {
78 // Test(default(int), guidVal);
79 // }
80 //
81 [Overload] public abstract void Test(Guid guidVal);
82
83 // Becomes
84 // public override void Test(Guid guidVal, int intVal)
85 // {
86 // Test(intVal, guidVal);
87 // }
88 //
89 [Overload] public abstract void Test(Guid guidVal, int intVal);
90
91 // Becomes
92 // public override void Test(string strVal)
93 // {
94 // Test(default(int), strVal);
95 // }
96 //
97 [Overload]
98 public abstract void Test(string strVal);
99
100 // Overload method name may be altered.
101 //
102 [Overload("Test")]
103 public abstract void GuidTest(Guid guidVal, DateTime dateVal);
104
105 // Parameter types of the method to overload.
106 //
107 [Overload(typeof(int), typeof(Guid))]
108 public abstract void Test(DateTime strVal);
109
110 // There may be more or less parameters in the overloaded method.
111 //
112 [Overload] public abstract void OutRefTest(int inVal, out int outVal, ref int refVal, out string strVal);
113 [Overload] public abstract void OutRefTest(int inVal);
114
115 // Value types and ref value types also works.
116 //
117 [Overload] public abstract void OutRefStructTest(int? inVal, out int? outVal, ref int? refVal, out Guid guidVal);
118 [Overload] public abstract void OutRefStructTest(int? inVal);
119
120 // We can overload static methods.
121 //
122 [Overload] public abstract int StaticMethod(int intVal);
123
124 // We can overload methods declared in a base type.
125 //
126 [Overload] public abstract string ToString(int intVal);
127
128 // A generic method can be overloaded by an other generic method.
129 //
130 [Overload] public abstract T Generic<T>(T inVal);
131 }
132
133 [Test]
134 public void OverloadTest()
135 {
136 TestObject o = TypeAccessor<TestObject>.CreateInstance();
137
138 o.Test(12345, "str");
139
140 Assert.AreEqual(12345, o.IntValue);
141 Assert.AreEqual("str", o.StrValue);
142 Assert.AreEqual(Guid.Empty, o.GuidValue);
143
144 o.Test(Guid.NewGuid(), 123);
145
146 Assert.AreEqual(123, o.IntValue);
147 Assert.AreEqual("(default)", o.StrValue);
148 Assert.AreNotEqual(Guid.Empty, o.GuidValue);
149
150 o.Test("foo");
151
152 Assert.AreEqual(0, o.IntValue);
153 Assert.AreEqual("foo", o.StrValue);
154 Assert.AreEqual(Guid.Empty, o.GuidValue);
155
156 o.Test(Guid.NewGuid());
157
158 Assert.AreEqual(0, o.IntValue);
159 Assert.AreEqual("(default)", o.StrValue);
160 Assert.AreNotEqual(Guid.Empty, o.GuidValue);
161
162 Assert.AreEqual(1, o.Generic(1));
163 }
164
165 [Test]
166 public void AnyNameTest()
167 {
168 TestObject o = TypeAccessor<TestObject>.CreateInstance();
169
170 o.GuidTest(Guid.NewGuid(), DateTime.Now);
171
172 Assert.AreEqual(0, o.IntValue);
173 Assert.AreEqual("(default)", o.StrValue);
174 Assert.AreNotEqual(Guid.Empty, o.GuidValue);
175 }
176
177 [Test]
178 public void ExplicitParameterTypesTest()
179 {
180 TestObject o = TypeAccessor<TestObject>.CreateInstance();
181
182 o.Test(DateTime.Now);
183
184 Assert.AreEqual(0, o.IntValue);
185 Assert.AreEqual("(default)", o.StrValue);
186 Assert.AreEqual(Guid.Empty, o.GuidValue);
187 }
188
189 [Test]
190 public void StaticMethodTest()
191 {
192 TestObject o = TypeAccessor<TestObject>.CreateInstance();
193
194 int intVal = o.StaticMethod(123);
195
196 Assert.AreEqual(123, intVal);
197 }
198
199 [Test]
200 public void BaseTypeMethodTest()
201 {
202 TestObject o = TypeAccessor<TestObject>.CreateInstance();
203
204 Assert.AreEqual(o.ToString(), o.ToString(123));
205 }
206
207 [Test]
208 public void OutRefTest()
209 {
210 TestObject o = TypeAccessor<TestObject>.CreateInstance();
211
212 const int inVal = 123;
213 int refVal = 99;
214 int outVal;
215 string strVal;
216 o.OutRefTest(inVal, out outVal, ref refVal, out strVal);
217
218 Assert.AreEqual(inVal, outVal);
219 Assert.AreEqual(222, refVal);
220 Assert.AreEqual(string.Empty, strVal);
221
222 o.OutRefTest(inVal);
223 }
224
225 [Test]
226 public void OutRefStructTest()
227 {
228 TestObject o = TypeAccessor<TestObject>.CreateInstance();
229
230 int? inVal = 123;
231 int? refVal = 99;
232 int? outVal;
233 Guid guidVal;
234 o.OutRefStructTest(inVal, out outVal, ref refVal, out guidVal);
235
236 Assert.AreEqual(inVal, outVal);
237 Assert.AreEqual(222, refVal);
238 Assert.AreEqual(Guid.Empty, guidVal);
239
240 o.OutRefStructTest(inVal);
241 }
242
243 [Test]
244 public void GenericTypeTest()
245 {
246 TestObject<int?> o = TypeAccessor<TestObject<int?>>.CreateInstance();
247
248 int? inVal = 123;
249 int? refVal = 99;
250 int? outVal;
251 o.Test(inVal, out outVal, ref refVal);
252
253 Assert.AreEqual(inVal, outVal);
254 Assert.AreEqual(refVal, 99);
255
256 Assert.AreEqual(inVal, o.Test(inVal));
257 Assert.AreEqual(12, o.Test(12, DateTime.Now));
258
259 TestObject<string> o2 = TypeAccessor<TestObject<string>>.CreateInstance();
260
261 // When T is a string, method Test(DateTime, string) becomes the best match.
262 //
263 Assert.AreEqual("STR", o2.Test("str", DateTime.Now));
264 }
265
266 }
267 }