|
0
|
1 using System;
|
|
|
2 using System.Collections;
|
|
|
3 using System.Collections.Generic;
|
|
|
4 using System.Data;
|
|
|
5 using System.Data.SqlTypes;
|
|
|
6 using System.Globalization;
|
|
|
7 using BLToolkit.Common;
|
|
|
8 using BLToolkit.Reflection;
|
|
|
9 using NUnit.Framework;
|
|
|
10
|
|
|
11 using BLToolkit.Mapping;
|
|
|
12
|
|
|
13 namespace Mapping
|
|
|
14 {
|
|
|
15 [TestFixture, Category("Mapping")]
|
|
|
16 public class MapTest : TestFixtureBase
|
|
|
17 {
|
|
|
18 #region Enum To Int
|
|
|
19
|
|
|
20 public class EnumClass
|
|
|
21 {
|
|
|
22 public enum Enum
|
|
|
23 {
|
|
|
24 Value1 = 1,
|
|
|
25 Value2 = 2
|
|
|
26 }
|
|
|
27
|
|
|
28 public Enum Value = Enum.Value1;
|
|
|
29 public Enum? NullableValue = Enum.Value2;
|
|
|
30 }
|
|
|
31
|
|
|
32 public class IntClass
|
|
|
33 {
|
|
|
34 public int Value;
|
|
|
35 public int? NullableValue;
|
|
|
36 }
|
|
|
37
|
|
|
38 [Test]
|
|
|
39 public void EnumToInt()
|
|
|
40 {
|
|
|
41 var list1 = new ArrayList();
|
|
|
42
|
|
|
43 list1.Add(new EnumClass());
|
|
|
44
|
|
|
45 var list2 = Map.ListToList(list1, typeof(IntClass));
|
|
|
46
|
|
|
47 Assert.AreEqual(1, ((IntClass)list2[0]).Value);
|
|
|
48 Assert.AreEqual(2, ((IntClass)list2[0]).NullableValue);
|
|
|
49 }
|
|
|
50
|
|
|
51 #endregion
|
|
|
52
|
|
|
53 #region ToEnum, FromEnum
|
|
|
54
|
|
|
55 [DefaultValue(Enum1.Value3)]
|
|
|
56 [MapValue(Enum1.Value2, "2")]
|
|
|
57 public enum Enum1
|
|
|
58 {
|
|
|
59 [MapValue("1")] Value1,
|
|
|
60 [NullValue] Value2,
|
|
|
61 [MapValue("3")] Value3
|
|
|
62 }
|
|
|
63
|
|
|
64 [Test]
|
|
|
65 public void ToEnum()
|
|
|
66 {
|
|
|
67 Assert.AreEqual(Enum1.Value1, Map.ValueToEnum("1", typeof(Enum1)));
|
|
|
68 Assert.AreEqual(Enum1.Value2, Map.ValueToEnum(null, typeof(Enum1)));
|
|
|
69 Assert.AreEqual(Enum1.Value3, Map.ValueToEnum("2727", typeof(Enum1)));
|
|
|
70 }
|
|
|
71
|
|
|
72 [Test]
|
|
|
73 public void FromEnum()
|
|
|
74 {
|
|
|
75 Assert.AreEqual("1", Map.EnumToValue(Enum1.Value1));
|
|
|
76 Assert.IsNull ( Map.EnumToValue(Enum1.Value2));
|
|
|
77 Assert.AreEqual("3", Map.EnumToValue(Enum1.Value3));
|
|
|
78 }
|
|
|
79
|
|
|
80 public enum Enum2 : short
|
|
|
81 {
|
|
|
82 Value1 = 1,
|
|
|
83 [NullValue] Value2,
|
|
|
84 [DefaultValue]Value3
|
|
|
85 }
|
|
|
86
|
|
|
87 [Test]
|
|
|
88 public void ToShortEnum()
|
|
|
89 {
|
|
|
90 Assert.AreEqual(Enum2.Value1, Map.ValueToEnum(1, typeof(Enum2)));
|
|
|
91 Assert.AreEqual(Enum2.Value2, Map.ValueToEnum(null, typeof(Enum2)));
|
|
|
92 Assert.AreEqual(Enum2.Value3, Map.ValueToEnum(3, typeof(Enum2)));
|
|
|
93 Assert.AreEqual(Enum2.Value3, Map.ValueToEnum(2727, typeof(Enum2)));
|
|
|
94
|
|
|
95 // DateTime.Now can't converted to Enum2.
|
|
|
96 // Expected result in this case is default value.
|
|
|
97 //
|
|
|
98 Assert.AreEqual(Enum2.Value3, Map.ValueToEnum(DateTime.Now, typeof(Enum2)));
|
|
|
99 }
|
|
|
100
|
|
|
101 public enum Enum3 : long
|
|
|
102 {
|
|
|
103 Value1 = 1,
|
|
|
104 }
|
|
|
105
|
|
|
106 [Test, ExpectedException(typeof(InvalidCastException))]
|
|
|
107 public void ToEnumWithIncompatibleValue()
|
|
|
108 {
|
|
|
109 // An object can't be converted to Enum3.
|
|
|
110 // Expected result is an exception, since Enum3 does not have
|
|
|
111 // a default value defined.
|
|
|
112 //
|
|
|
113 Map.ValueToEnum(new object(), typeof(Enum3));
|
|
|
114 }
|
|
|
115
|
|
|
116 [Test]
|
|
|
117 public void ToEnumWithCompatibleValue()
|
|
|
118 {
|
|
|
119 // 123 is not defined for this enum, but can be converted to.
|
|
|
120 // Enum3 does not have a default value defined, so just cast 123 to Enum3
|
|
|
121 //
|
|
|
122 Assert.AreEqual((Enum3)123, Map.ValueToEnum(123, typeof(Enum3)));
|
|
|
123
|
|
|
124 // DateTime.Now also can be converted to Enum3 (as ticks).
|
|
|
125 //
|
|
|
126 Map.ValueToEnum(DateTime.Now, typeof(Enum3));
|
|
|
127 }
|
|
|
128 #endregion
|
|
|
129
|
|
|
130 #region ObjectToObject
|
|
|
131
|
|
|
132 public class SourceObject
|
|
|
133 {
|
|
|
134 public int Field1 = 10;
|
|
|
135 public string Field2 = "20";
|
|
|
136 public double Field3 = 30.0;
|
|
|
137 }
|
|
|
138
|
|
|
139 public class Object1
|
|
|
140 {
|
|
|
141 public int Field1;
|
|
|
142 public int Field2;
|
|
|
143 public int Field3;
|
|
|
144 }
|
|
|
145
|
|
|
146 [Test]
|
|
|
147 public void ObjectToObjectOO()
|
|
|
148 {
|
|
|
149 SourceObject so = new SourceObject();
|
|
|
150 Object1 o = new Object1();
|
|
|
151
|
|
|
152 Map.ObjectToObject(so, o);
|
|
|
153
|
|
|
154 Assert.AreEqual(10, o.Field1);
|
|
|
155 Assert.AreEqual(20, o.Field2);
|
|
|
156 Assert.AreEqual(30, o.Field3);
|
|
|
157 }
|
|
|
158
|
|
|
159 [Test]
|
|
|
160 public void ObjectToObjectOT()
|
|
|
161 {
|
|
|
162 SourceObject so = new SourceObject();
|
|
|
163 Object1 o = (Object1)Map.ObjectToObject(so, typeof(Object1));
|
|
|
164
|
|
|
165 Assert.AreEqual(10, o.Field1);
|
|
|
166 Assert.AreEqual(20, o.Field2);
|
|
|
167 Assert.AreEqual(30, o.Field3);
|
|
|
168 }
|
|
|
169
|
|
|
170 [Test]
|
|
|
171 public void ObjectToObjectTO()
|
|
|
172 {
|
|
|
173 SourceObject so = new SourceObject();
|
|
|
174 Object1 o = Map.ObjectToObject<Object1>(so);
|
|
|
175
|
|
|
176 Assert.AreEqual(10, o.Field1);
|
|
|
177 Assert.AreEqual(20, o.Field2);
|
|
|
178 Assert.AreEqual(30, o.Field3);
|
|
|
179 }
|
|
|
180
|
|
|
181 public class DefaultNullType
|
|
|
182 {
|
|
|
183 [NullValue(-1)]
|
|
|
184 public int NullableInt;
|
|
|
185 }
|
|
|
186
|
|
|
187 #endregion
|
|
|
188
|
|
|
189 #region DataRowToObject
|
|
|
190
|
|
|
191 [Test]
|
|
|
192 public void DataRowToObjectD()
|
|
|
193 {
|
|
|
194 DataTable table = new DataTable();
|
|
|
195
|
|
|
196 table.Columns.Add("NullableInt", typeof(int));
|
|
|
197
|
|
|
198 table.Rows.Add(new object[] { DBNull.Value });
|
|
|
199 table.Rows.Add(new object[] { 1 });
|
|
|
200 table.AcceptChanges();
|
|
|
201
|
|
|
202 DefaultNullType dn = (DefaultNullType)Map.DataRowToObject(table.Rows[0], typeof(DefaultNullType));
|
|
|
203
|
|
|
204 Assert.AreEqual(-1, dn.NullableInt);
|
|
|
205
|
|
|
206 Map.DataRowToObject(table.Rows[1], DataRowVersion.Current, dn);
|
|
|
207
|
|
|
208 Assert.AreEqual(1, dn.NullableInt);
|
|
|
209 }
|
|
|
210
|
|
|
211 #endregion
|
|
|
212
|
|
|
213 #region ObjectToDictionary
|
|
|
214
|
|
|
215 [Test]
|
|
|
216 public void ObjectToDictionary()
|
|
|
217 {
|
|
|
218 SourceObject so = new SourceObject();
|
|
|
219 Hashtable ht = new Hashtable();
|
|
|
220
|
|
|
221 Map.ObjectToDictionary(so, ht);
|
|
|
222
|
|
|
223 Assert.AreEqual(10, ht["Field1"]);
|
|
|
224 Assert.AreEqual("20", ht["Field2"]);
|
|
|
225 Assert.AreEqual(30, ht["Field3"]);
|
|
|
226 }
|
|
|
227
|
|
|
228 #endregion
|
|
|
229
|
|
|
230 #region DictionaryToObject
|
|
|
231
|
|
|
232 [Test]
|
|
|
233 public void DictionaryToObject()
|
|
|
234 {
|
|
|
235 var so = new SourceObject();
|
|
|
236 var ht = Map.ObjectToDictionary(so);
|
|
|
237 var o1 = (Object1)Map.DictionaryToObject(ht, typeof(Object1));
|
|
|
238
|
|
|
239 Assert.AreEqual(10, o1.Field1);
|
|
|
240 Assert.AreEqual(20, o1.Field2);
|
|
|
241 Assert.AreEqual(30, o1.Field3);
|
|
|
242 }
|
|
|
243
|
|
|
244 #endregion
|
|
|
245
|
|
|
246 #region DataRowToDictionary
|
|
|
247
|
|
|
248 [Test]
|
|
|
249 public void DataRowToDictionary()
|
|
|
250 {
|
|
|
251 DataTable table = GetDataTable();
|
|
|
252 Hashtable hash = Map.DataRowToDictionary(table.Rows[0]);
|
|
|
253
|
|
|
254 Assert.AreEqual(table.Rows[0]["ID"], hash["ID"]);
|
|
|
255 Assert.AreEqual(table.Rows[0]["Name"], hash["Name"]);
|
|
|
256 Assert.AreEqual(table.Rows[0]["Date"], hash["Date"]);
|
|
|
257 }
|
|
|
258
|
|
|
259 #endregion
|
|
|
260
|
|
|
261 #region DictionaryToDataRow
|
|
|
262
|
|
|
263 [Test]
|
|
|
264 public void DictionaryToDataRow()
|
|
|
265 {
|
|
|
266 DataTable table1 = GetDataTable();
|
|
|
267 Hashtable hash = Map.DataRowToDictionary(table1.Rows[0]);
|
|
|
268 DataTable table2 = new DataTable();
|
|
|
269
|
|
|
270 Map.DictionaryToDataRow(hash, table2);
|
|
|
271
|
|
|
272 Assert.AreEqual(table1.Rows[0]["ID"], table2.Rows[0]["ID"]);
|
|
|
273 Assert.AreEqual(table1.Rows[0]["Name"], table2.Rows[0]["Name"]);
|
|
|
274 Assert.AreEqual(table1.Rows[0]["Date"], table2.Rows[0]["Date"]);
|
|
|
275 }
|
|
|
276
|
|
|
277 #endregion
|
|
|
278
|
|
|
279 #region SqlTypes
|
|
|
280
|
|
|
281 public class SqlTypeTypes
|
|
|
282 {
|
|
|
283 public class SourceObject
|
|
|
284 {
|
|
|
285 public string s1 = "123";
|
|
|
286 public SqlString s2 = "1234";
|
|
|
287 public int i1 = 123;
|
|
|
288 public SqlInt32 i2 = 1234;
|
|
|
289
|
|
|
290 public DateTime d1 = DateTime.Now;
|
|
|
291 public SqlDateTime d2 = DateTime.Now;
|
|
|
292 }
|
|
|
293
|
|
|
294 public class Object1
|
|
|
295 {
|
|
|
296 public SqlString s1;
|
|
|
297 public string s2;
|
|
|
298 public SqlInt32 i1;
|
|
|
299 public int i2;
|
|
|
300
|
|
|
301 public SqlDateTime d1;
|
|
|
302 public DateTime d2;
|
|
|
303 }
|
|
|
304 }
|
|
|
305
|
|
|
306 [Test]
|
|
|
307 public void SqlTypes()
|
|
|
308 {
|
|
|
309 SqlTypeTypes.SourceObject so = new SqlTypeTypes.SourceObject();
|
|
|
310 SqlTypeTypes.Object1 o = (SqlTypeTypes.Object1)Map.ObjectToObject(so, typeof(SqlTypeTypes.Object1));
|
|
|
311
|
|
|
312 Console.WriteLine(o.s1); Assert.AreEqual("123", o.s1.Value);
|
|
|
313 Console.WriteLine(o.s2); Assert.AreEqual("1234", o.s2);
|
|
|
314
|
|
|
315 Console.WriteLine(o.i1); Assert.IsTrue(o.i1.Value == 123);
|
|
|
316 Console.WriteLine(o.i2); Assert.IsTrue(o.i2 == 1234);
|
|
|
317
|
|
|
318 Console.WriteLine("{0} - {1}", so.d2, o.d2); Assert.AreEqual(o.d2, so.d2.Value);
|
|
|
319 //Console.WriteLine("{0} - {1}", s.d1, d.d1); Assert.IsTrue(d.d1.Value == s.d1);
|
|
|
320 }
|
|
|
321
|
|
|
322 #endregion
|
|
|
323
|
|
|
324 #region Arrays
|
|
|
325
|
|
|
326 public class ArrayTypes
|
|
|
327 {
|
|
|
328 public class SourceObject
|
|
|
329 {
|
|
|
330 public int[,] DimArray = new int[2, 2] { {1,2}, {3,4} };
|
|
|
331 public string[] StrArray = new string[] {"5","4","3","2","1"};
|
|
|
332 public int[] IntArray = new int[] {1,2,3,4,5};
|
|
|
333 public Enum1[] EnmArray = new Enum1[] {Enum1.Value1,Enum1.Value2,Enum1.Value3};
|
|
|
334
|
|
|
335 public byte[][,][][,] ComplexArray = InitComplexArray();
|
|
|
336 public static byte[][,][][,] InitComplexArray()
|
|
|
337 {
|
|
|
338 byte[][,][][,] ret = new byte[1][,][][,];
|
|
|
339 ret[0] = new byte[1,1][][,];
|
|
|
340 ret[0][0,0] = new byte[1][,];
|
|
|
341 ret[0][0,0][0] = new byte[,] { {1,2}, {3,4} };
|
|
|
342
|
|
|
343 return ret;
|
|
|
344 }
|
|
|
345 }
|
|
|
346
|
|
|
347 public class DestObject
|
|
|
348 {
|
|
|
349 public float[,] DimArray;
|
|
|
350 public string[] StrArray;
|
|
|
351 public string[] IntArray;
|
|
|
352 public string[] EnmArray;
|
|
|
353 public sbyte[][,][][,] ComplexArray;
|
|
|
354 }
|
|
|
355
|
|
|
356 public class IncompatibleObject
|
|
|
357 {
|
|
|
358 public int[][] DimArray;
|
|
|
359 }
|
|
|
360 }
|
|
|
361
|
|
|
362 [Test]
|
|
|
363 public void ArrayTypesTest()
|
|
|
364 {
|
|
|
365 ArrayTypes.SourceObject so = new ArrayTypes.SourceObject();
|
|
|
366 ArrayTypes.DestObject o = (ArrayTypes.DestObject)Map.ObjectToObject(so, typeof(ArrayTypes.DestObject));
|
|
|
367
|
|
|
368 Console.WriteLine(o.DimArray); Assert.AreEqual(so.DimArray[0,0], (int)o.DimArray[0,0]);
|
|
|
369 Console.WriteLine(o.StrArray); Assert.AreEqual(so.StrArray, o.StrArray);
|
|
|
370 Console.WriteLine(o.IntArray); Assert.AreEqual(so.IntArray[0].ToString(), o.IntArray[0]);
|
|
|
371
|
|
|
372 Console.WriteLine(o.ComplexArray); Assert.IsTrue(o.ComplexArray[0][0,0][0][1,1] == 4);
|
|
|
373 }
|
|
|
374
|
|
|
375 [Test, ExpectedException(typeof(InvalidCastException))]
|
|
|
376 public void IncompatibleArrayTypesTest()
|
|
|
377 {
|
|
|
378 ArrayTypes.SourceObject so = new ArrayTypes.SourceObject();
|
|
|
379 Map.ObjectToObject(so, typeof(ArrayTypes.IncompatibleObject));
|
|
|
380 }
|
|
|
381
|
|
|
382 #endregion
|
|
|
383
|
|
|
384 #region SourceListToDestList
|
|
|
385
|
|
|
386 [Test]
|
|
|
387 public void ListToList()
|
|
|
388 {
|
|
|
389 DataTable table = GetDataTable();
|
|
|
390 ArrayList list1 = Map.DataTableToList(table, typeof(TestObject));
|
|
|
391 ArrayList list2 = new ArrayList();
|
|
|
392
|
|
|
393 Map.ListToList(list1, list2, typeof(TestObject));
|
|
|
394
|
|
|
395 CompareLists(table, list2);
|
|
|
396 }
|
|
|
397
|
|
|
398 [Test]
|
|
|
399 public void TableToList()
|
|
|
400 {
|
|
|
401 DataTable table = GetDataTable();
|
|
|
402 ArrayList list = Map.DataTableToList(table, typeof(TestObject));
|
|
|
403
|
|
|
404 CompareLists(table, list);
|
|
|
405 }
|
|
|
406
|
|
|
407 [Test]
|
|
|
408 public void ListToTable1()
|
|
|
409 {
|
|
|
410 DataTable table1 = GetDataTable();
|
|
|
411 ArrayList list = Map.DataTableToList(table1, typeof(TestObject));
|
|
|
412 DataTable table2 = Map.ListToDataTable(list);
|
|
|
413
|
|
|
414 table2.AcceptChanges();
|
|
|
415
|
|
|
416 CompareLists(table1, table2);
|
|
|
417 }
|
|
|
418
|
|
|
419 [Test]
|
|
|
420 public void ListToTable2()
|
|
|
421 {
|
|
|
422 DataTable table1 = GetDataTable();
|
|
|
423 ArrayList list = Map.DataTableToList(table1, typeof(TestObject));
|
|
|
424 DataTable table2 = table1.Clone();
|
|
|
425
|
|
|
426 Map.ListToDataTable(list, table2);
|
|
|
427
|
|
|
428 table2.AcceptChanges();
|
|
|
429
|
|
|
430 CompareLists(table1, table2);
|
|
|
431 }
|
|
|
432
|
|
|
433 [Test]
|
|
|
434 public void TableToTable1()
|
|
|
435 {
|
|
|
436 DataTable table1 = GetDataTable();
|
|
|
437 DataTable table2 = Map.DataTableToDataTable(table1);
|
|
|
438
|
|
|
439 table2.AcceptChanges();
|
|
|
440
|
|
|
441 CompareLists(table1, table2);
|
|
|
442 }
|
|
|
443
|
|
|
444 [Test]
|
|
|
445 public void TableToTable2()
|
|
|
446 {
|
|
|
447 DataTable table1 = GetDataTable();
|
|
|
448 DataTable table2 = new DataTable();
|
|
|
449
|
|
|
450 Map.DataTableToDataTable(table1, table2);
|
|
|
451
|
|
|
452 table2.AcceptChanges();
|
|
|
453
|
|
|
454 CompareLists(table1, table2);
|
|
|
455 }
|
|
|
456
|
|
|
457 [Test]
|
|
|
458 public void TableToDictionary()
|
|
|
459 {
|
|
|
460 DataTable table = GetDataTable();
|
|
|
461 IDictionary dic = Map.DataTableToDictionary(table, new SortedList(), "ID", typeof(TestObject));
|
|
|
462
|
|
|
463 CompareLists(table, Map.ListToList(dic.Values, typeof(TestObject)));
|
|
|
464 }
|
|
|
465
|
|
|
466 [Test]
|
|
|
467 public void ListToDictionary()
|
|
|
468 {
|
|
|
469 DataTable table = GetDataTable();
|
|
|
470 ArrayList list = Map.DataTableToList (table, typeof(TestObject));
|
|
|
471 IDictionary dic = Map.ListToDictionary(list, new SortedList(), "ID", typeof(TestObject));
|
|
|
472
|
|
|
473 CompareLists(table, Map.ListToList(dic.Values, typeof(TestObject)));
|
|
|
474 }
|
|
|
475
|
|
|
476 [Test]
|
|
|
477 public void DictionaryToDictionary()
|
|
|
478 {
|
|
|
479 DataTable table = GetDataTable();
|
|
|
480 ArrayList list = Map.DataTableToList (table, typeof(TestObject));
|
|
|
481 IDictionary dic1 = Map.ListToDictionary (list, new SortedList(), "ID", typeof(TestObject));
|
|
|
482 IDictionary dic2 = Map.DictionaryToDictionary(dic1, new SortedList(), "@ID", typeof(TestObject));
|
|
|
483
|
|
|
484 CompareLists(table, Map.ListToList(dic2.Values, typeof(TestObject)));
|
|
|
485 }
|
|
|
486
|
|
|
487 #endregion
|
|
|
488
|
|
|
489 #region ObjectToDataRow
|
|
|
490
|
|
|
491 public class DataRowTestType
|
|
|
492 {
|
|
|
493 public Int32 Int32Column = 12345;
|
|
|
494 public String StringColumn = "string";
|
|
|
495 public Byte[] ByteArrayColumn = new Byte[]{1,2,3,4,5};
|
|
|
496 //public Byte[] ByteArrayColumn2 = null;
|
|
|
497 }
|
|
|
498
|
|
|
499 [Test]
|
|
|
500 public void ObjectToDataRowTest()
|
|
|
501 {
|
|
|
502 DataTable table = new DataTable();
|
|
|
503 DataRowTestType obj = new DataRowTestType();
|
|
|
504
|
|
|
505 Map.ObjectToDataRow(obj, table);
|
|
|
506
|
|
|
507 Assert.IsNotEmpty(table.Rows);
|
|
|
508 DataRow dr = table.Rows[0];
|
|
|
509
|
|
|
510 Assert.AreEqual(table.Columns["Int32Column"] .DataType, typeof(Int32));
|
|
|
511 Assert.AreEqual(table.Columns["StringColumn"] .DataType, typeof(String));
|
|
|
512 Assert.AreEqual(table.Columns["ByteArrayColumn"] .DataType, typeof(Byte[]));
|
|
|
513 //Assert.AreEqual(table.Columns["ByteArrayColumn2"].DataType, typeof(Byte[]));
|
|
|
514
|
|
|
515 Assert.AreEqual(obj.Int32Column, dr["Int32Column"]);
|
|
|
516 Assert.AreEqual(obj.StringColumn, dr["StringColumn"]);
|
|
|
517 Assert.AreEqual(obj.ByteArrayColumn, dr["ByteArrayColumn"]);
|
|
|
518 //Assert.AreEqual(obj.ByteArrayColumn2, dr["ByteArrayColumn2"]);
|
|
|
519 }
|
|
|
520
|
|
|
521 #endregion
|
|
|
522
|
|
|
523 class ObjectStr1
|
|
|
524 {
|
|
|
525 public string Field;
|
|
|
526 }
|
|
|
527
|
|
|
528 class ObjectDateTime1
|
|
|
529 {
|
|
|
530 public DateTime Field = DateTime.Now;
|
|
|
531 }
|
|
|
532
|
|
|
533 [Test]
|
|
|
534 public void TestConverter()
|
|
|
535 {
|
|
|
536 var prev = Convert<DateTime,string>.From;
|
|
|
537
|
|
|
538 Convert<DateTime,string>.From = str =>
|
|
|
539 DateTime.ParseExact(str, new[] { "yyyymmdd" }, CultureInfo.InvariantCulture, DateTimeStyles.None);
|
|
|
540
|
|
|
541 var map = Map.GetObjectMapper<List<ObjectStr1>,List<ObjectDateTime1>>();
|
|
|
542 var obj = map(new List<ObjectStr1> { new ObjectStr1 { Field = "20110102" } });
|
|
|
543
|
|
|
544 Assert.That(obj.Count, Is.EqualTo(1));
|
|
|
545 Assert.That(obj[0].Field.Year, Is.EqualTo(2011));
|
|
|
546
|
|
|
547 Convert<DateTime,string>.From = prev;
|
|
|
548 }
|
|
|
549
|
|
|
550 public abstract class Test
|
|
|
551 {
|
|
|
552 public abstract int Id { get; set; }
|
|
|
553 }
|
|
|
554
|
|
|
555 [Test]
|
|
|
556 public void AccessorTest()
|
|
|
557 {
|
|
|
558 var test = TypeAccessor<Test>.CreateInstance();
|
|
|
559 var mapper = Map.GetObjectMapper<Test,Test>();
|
|
|
560 var testCopy = mapper(test);
|
|
|
561 }
|
|
|
562 }
|
|
|
563 }
|
