--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/UnitTests/CS/Mapping/MapTest.cs	Thu Mar 27 21:46:09 2014 +0400
@@ -0,0 +1,563 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlTypes;
+using System.Globalization;
+using BLToolkit.Common;
+using BLToolkit.Reflection;
+using NUnit.Framework;
+
+using BLToolkit.Mapping;
+
+namespace Mapping
+{
+	[TestFixture, Category("Mapping")]
+	public class MapTest : TestFixtureBase
+	{
+		#region Enum To Int
+
+		public class EnumClass
+		{
+			public enum Enum
+			{
+				Value1 = 1,
+				Value2 = 2
+			}
+
+			public Enum          Value = Enum.Value1;
+			public Enum? NullableValue = Enum.Value2;
+		}
+
+		public class IntClass
+		{
+			public int          Value;
+			public int? NullableValue;
+		}
+
+		[Test]
+		public void EnumToInt()
+		{
+			var list1 = new ArrayList();
+
+			list1.Add(new EnumClass());
+
+			var list2 = Map.ListToList(list1, typeof(IntClass));
+
+			Assert.AreEqual(1, ((IntClass)list2[0]).Value);
+			Assert.AreEqual(2, ((IntClass)list2[0]).NullableValue);
+		}
+
+		#endregion
+
+		#region ToEnum, FromEnum
+
+		[DefaultValue(Enum1.Value3)]
+		[MapValue(Enum1.Value2, "2")]
+		public enum Enum1
+		{
+			[MapValue("1")] Value1,
+			[NullValue]     Value2,
+			[MapValue("3")] Value3
+		}
+
+		[Test]
+		public void ToEnum()
+		{
+			Assert.AreEqual(Enum1.Value1, Map.ValueToEnum("1",    typeof(Enum1)));
+			Assert.AreEqual(Enum1.Value2, Map.ValueToEnum(null,   typeof(Enum1)));
+			Assert.AreEqual(Enum1.Value3, Map.ValueToEnum("2727", typeof(Enum1)));
+		}
+
+		[Test]
+		public void FromEnum()
+		{
+			Assert.AreEqual("1", Map.EnumToValue(Enum1.Value1));
+			Assert.IsNull  (     Map.EnumToValue(Enum1.Value2));
+			Assert.AreEqual("3", Map.EnumToValue(Enum1.Value3));
+		}
+
+		public enum Enum2 : short
+		{
+			Value1 = 1,
+			[NullValue] Value2,
+			[DefaultValue]Value3
+		}
+
+		[Test]
+		public void ToShortEnum()
+		{
+			Assert.AreEqual(Enum2.Value1, Map.ValueToEnum(1,    typeof(Enum2)));
+			Assert.AreEqual(Enum2.Value2, Map.ValueToEnum(null, typeof(Enum2)));
+			Assert.AreEqual(Enum2.Value3, Map.ValueToEnum(3,    typeof(Enum2)));
+			Assert.AreEqual(Enum2.Value3, Map.ValueToEnum(2727, typeof(Enum2)));
+
+			// DateTime.Now can't converted to Enum2.
+			// Expected result in this case is default value.
+			//
+			Assert.AreEqual(Enum2.Value3, Map.ValueToEnum(DateTime.Now, typeof(Enum2)));
+		}
+
+		public enum Enum3 : long
+		{
+			Value1 = 1,
+		}
+
+		[Test, ExpectedException(typeof(InvalidCastException))]
+		public void ToEnumWithIncompatibleValue()
+		{
+			// An object can't be converted to Enum3.
+			// Expected result is an exception, since Enum3 does not have
+			// a default value defined.
+			//
+			Map.ValueToEnum(new object(), typeof(Enum3));
+		}
+
+		[Test]
+		public void ToEnumWithCompatibleValue()
+		{
+			// 123 is not defined for this enum, but can be converted to.
+			// Enum3 does not have a default value defined, so just cast 123 to Enum3
+			//
+			Assert.AreEqual((Enum3)123, Map.ValueToEnum(123, typeof(Enum3)));
+
+			// DateTime.Now also can be converted to Enum3 (as ticks).
+			//
+			Map.ValueToEnum(DateTime.Now, typeof(Enum3));
+		}
+		#endregion
+
+		#region ObjectToObject
+
+		public class SourceObject
+		{
+			public int    Field1 = 10;
+			public string Field2 = "20";
+			public double Field3 = 30.0;
+		}
+
+		public class Object1
+		{
+			public int Field1;
+			public int Field2;
+			public int Field3;
+		}
+
+		[Test]
+		public void ObjectToObjectOO()
+		{
+			SourceObject so = new SourceObject();
+			Object1      o  = new Object1();
+ 
+			Map.ObjectToObject(so, o);
+
+			Assert.AreEqual(10, o.Field1);
+			Assert.AreEqual(20, o.Field2);
+			Assert.AreEqual(30, o.Field3);
+		}
+
+		[Test]
+		public void ObjectToObjectOT()
+		{
+			SourceObject so = new SourceObject();
+			Object1      o  = (Object1)Map.ObjectToObject(so, typeof(Object1));
+
+			Assert.AreEqual(10, o.Field1);
+			Assert.AreEqual(20, o.Field2);
+			Assert.AreEqual(30, o.Field3);
+		}
+
+		[Test]
+		public void ObjectToObjectTO()
+		{
+			SourceObject so = new SourceObject();
+			Object1      o  = Map.ObjectToObject<Object1>(so);
+
+			Assert.AreEqual(10, o.Field1);
+			Assert.AreEqual(20, o.Field2);
+			Assert.AreEqual(30, o.Field3);
+		}
+
+		public class DefaultNullType
+		{
+			[NullValue(-1)]
+			public int NullableInt;
+		}
+
+		#endregion
+
+		#region DataRowToObject
+
+		[Test]
+		public void DataRowToObjectD()
+		{
+			DataTable table = new DataTable();
+
+			table.Columns.Add("NullableInt", typeof(int));
+
+			table.Rows.Add(new object[] { DBNull.Value });
+			table.Rows.Add(new object[] { 1 });
+			table.AcceptChanges();
+
+			DefaultNullType dn = (DefaultNullType)Map.DataRowToObject(table.Rows[0], typeof(DefaultNullType));
+
+			Assert.AreEqual(-1, dn.NullableInt);
+
+			Map.DataRowToObject(table.Rows[1], DataRowVersion.Current, dn);
+
+			Assert.AreEqual(1, dn.NullableInt);
+		}
+
+		#endregion
+
+		#region ObjectToDictionary
+
+		[Test]
+		public void ObjectToDictionary()
+		{
+			SourceObject so = new SourceObject();
+			Hashtable    ht = new Hashtable();
+ 
+			Map.ObjectToDictionary(so, ht);
+
+			Assert.AreEqual(10,   ht["Field1"]);
+			Assert.AreEqual("20", ht["Field2"]);
+			Assert.AreEqual(30,   ht["Field3"]);
+		}
+
+		#endregion
+
+		#region DictionaryToObject
+
+		[Test]
+		public void DictionaryToObject()
+		{
+			var so = new SourceObject();
+			var ht = Map.ObjectToDictionary(so);
+			var o1 = (Object1)Map.DictionaryToObject(ht, typeof(Object1));
+
+			Assert.AreEqual(10, o1.Field1);
+			Assert.AreEqual(20, o1.Field2);
+			Assert.AreEqual(30, o1.Field3);
+		}
+
+		#endregion
+
+		#region DataRowToDictionary
+
+		[Test]
+		public void DataRowToDictionary()
+		{
+			DataTable table = GetDataTable();
+			Hashtable hash  = Map.DataRowToDictionary(table.Rows[0]);
+
+			Assert.AreEqual(table.Rows[0]["ID"],   hash["ID"]);
+			Assert.AreEqual(table.Rows[0]["Name"], hash["Name"]);
+			Assert.AreEqual(table.Rows[0]["Date"], hash["Date"]);
+		}
+
+		#endregion
+
+		#region DictionaryToDataRow
+
+		[Test]
+		public void DictionaryToDataRow()
+		{
+			DataTable table1 = GetDataTable();
+			Hashtable hash   = Map.DataRowToDictionary(table1.Rows[0]);
+			DataTable table2 = new DataTable();
+
+			Map.DictionaryToDataRow(hash, table2);
+
+			Assert.AreEqual(table1.Rows[0]["ID"],   table2.Rows[0]["ID"]);
+			Assert.AreEqual(table1.Rows[0]["Name"], table2.Rows[0]["Name"]);
+			Assert.AreEqual(table1.Rows[0]["Date"], table2.Rows[0]["Date"]);
+		}
+
+		#endregion
+
+		#region SqlTypes
+
+		public class SqlTypeTypes
+		{
+			public class SourceObject
+			{
+				public string    s1 = "123";
+				public SqlString s2 = "1234";
+				public int       i1 = 123;
+				public SqlInt32  i2 = 1234;
+
+				public DateTime    d1 = DateTime.Now;
+				public SqlDateTime d2 = DateTime.Now;
+			}
+
+			public class Object1
+			{
+				public SqlString s1;
+				public string    s2;
+				public SqlInt32  i1;
+				public int       i2;
+
+				public SqlDateTime d1;
+				public DateTime    d2;
+			}
+		}
+
+		[Test]
+		public void SqlTypes()
+		{
+			SqlTypeTypes.SourceObject so = new SqlTypeTypes.SourceObject();
+			SqlTypeTypes.Object1      o  = (SqlTypeTypes.Object1)Map.ObjectToObject(so, typeof(SqlTypeTypes.Object1));
+
+			Console.WriteLine(o.s1); Assert.AreEqual("123",  o.s1.Value);
+			Console.WriteLine(o.s2); Assert.AreEqual("1234", o.s2);
+
+			Console.WriteLine(o.i1); Assert.IsTrue(o.i1.Value == 123);
+			Console.WriteLine(o.i2); Assert.IsTrue(o.i2 == 1234);
+
+			Console.WriteLine("{0} - {1}", so.d2, o.d2); Assert.AreEqual(o.d2, so.d2.Value);
+			//Console.WriteLine("{0} - {1}", s.d1, d.d1); Assert.IsTrue(d.d1.Value == s.d1);
+		}
+
+		#endregion
+
+		#region Arrays
+
+		public class ArrayTypes
+		{
+			public class SourceObject
+			{
+				public int[,]   DimArray = new int[2, 2] { {1,2}, {3,4} };
+				public string[] StrArray = new string[]  {"5","4","3","2","1"};
+				public int[]    IntArray = new int[]     {1,2,3,4,5};
+				public Enum1[]  EnmArray = new Enum1[]   {Enum1.Value1,Enum1.Value2,Enum1.Value3};
+
+				public byte[][,][][,] ComplexArray = InitComplexArray();
+				public static byte[][,][][,] InitComplexArray()
+				{
+					byte[][,][][,] ret = new byte[1][,][][,];
+					ret[0]             = new byte[1,1][][,];
+					ret[0][0,0]        = new byte[1][,];
+					ret[0][0,0][0]     = new byte[,] { {1,2}, {3,4} };
+
+					return ret;
+				}
+			}
+
+			public class DestObject
+			{
+				public float[,] DimArray;
+				public string[] StrArray;
+				public string[] IntArray;
+				public string[] EnmArray;
+				public sbyte[][,][][,] ComplexArray;
+			}
+
+			public class IncompatibleObject
+			{
+				public int[][] DimArray;
+			}
+		}
+
+		[Test]
+		public void ArrayTypesTest()
+		{
+			ArrayTypes.SourceObject so = new ArrayTypes.SourceObject();
+			ArrayTypes.DestObject o = (ArrayTypes.DestObject)Map.ObjectToObject(so, typeof(ArrayTypes.DestObject));
+
+			Console.WriteLine(o.DimArray); Assert.AreEqual(so.DimArray[0,0], (int)o.DimArray[0,0]);
+			Console.WriteLine(o.StrArray); Assert.AreEqual(so.StrArray, o.StrArray);
+			Console.WriteLine(o.IntArray); Assert.AreEqual(so.IntArray[0].ToString(), o.IntArray[0]);
+
+			Console.WriteLine(o.ComplexArray); Assert.IsTrue(o.ComplexArray[0][0,0][0][1,1] == 4);
+		}
+
+		[Test, ExpectedException(typeof(InvalidCastException))]
+		public void IncompatibleArrayTypesTest()
+		{
+			ArrayTypes.SourceObject so = new ArrayTypes.SourceObject();
+			Map.ObjectToObject(so, typeof(ArrayTypes.IncompatibleObject));
+		}
+		
+		#endregion
+
+		#region SourceListToDestList
+
+		[Test]
+		public void ListToList()
+		{
+			DataTable table = GetDataTable();
+			ArrayList list1 = Map.DataTableToList(table, typeof(TestObject));
+			ArrayList list2 = new ArrayList();
+
+			Map.ListToList(list1, list2, typeof(TestObject));
+
+			CompareLists(table, list2);
+		}
+
+		[Test]
+		public void TableToList()
+		{
+			DataTable table = GetDataTable();
+			ArrayList list  = Map.DataTableToList(table, typeof(TestObject));
+
+			CompareLists(table, list);
+		}
+
+		[Test]
+		public void ListToTable1()
+		{
+			DataTable table1 = GetDataTable();
+			ArrayList list   = Map.DataTableToList(table1, typeof(TestObject));
+			DataTable table2 = Map.ListToDataTable(list);
+
+			table2.AcceptChanges();
+
+			CompareLists(table1, table2);
+		}
+
+		[Test]
+		public void ListToTable2()
+		{
+			DataTable table1 = GetDataTable();
+			ArrayList list   = Map.DataTableToList(table1, typeof(TestObject));
+			DataTable table2 = table1.Clone();
+
+			Map.ListToDataTable(list, table2);
+
+			table2.AcceptChanges();
+
+			CompareLists(table1, table2);
+		}
+
+		[Test]
+		public void TableToTable1()
+		{
+			DataTable table1 = GetDataTable();
+			DataTable table2 = Map.DataTableToDataTable(table1);
+
+			table2.AcceptChanges();
+
+			CompareLists(table1, table2);
+		}
+
+		[Test]
+		public void TableToTable2()
+		{
+			DataTable table1 = GetDataTable();
+			DataTable table2 = new DataTable();
+				
+			Map.DataTableToDataTable(table1, table2);
+
+			table2.AcceptChanges();
+
+			CompareLists(table1, table2);
+		}
+
+		[Test]
+		public void TableToDictionary()
+		{
+			DataTable   table = GetDataTable();
+			IDictionary dic   = Map.DataTableToDictionary(table, new SortedList(), "ID", typeof(TestObject));
+
+			CompareLists(table, Map.ListToList(dic.Values, typeof(TestObject)));
+		}
+
+		[Test]
+		public void ListToDictionary()
+		{
+			DataTable   table = GetDataTable();
+			ArrayList   list  = Map.DataTableToList     (table, typeof(TestObject));
+			IDictionary dic   = Map.ListToDictionary(list, new SortedList(), "ID", typeof(TestObject));
+
+			CompareLists(table, Map.ListToList(dic.Values, typeof(TestObject)));
+		}
+
+		[Test]
+		public void DictionaryToDictionary()
+		{
+			DataTable   table = GetDataTable();
+			ArrayList   list  = Map.DataTableToList           (table, typeof(TestObject));
+			IDictionary dic1  = Map.ListToDictionary      (list, new SortedList(), "ID",  typeof(TestObject));
+			IDictionary dic2  = Map.DictionaryToDictionary(dic1, new SortedList(), "@ID", typeof(TestObject));
+
+			CompareLists(table, Map.ListToList(dic2.Values, typeof(TestObject)));
+		}
+
+		#endregion
+
+		#region ObjectToDataRow
+
+		public class DataRowTestType
+		{
+			public Int32      Int32Column  = 12345;
+			public String    StringColumn  = "string";
+			public Byte[] ByteArrayColumn  = new Byte[]{1,2,3,4,5};
+			//public Byte[] ByteArrayColumn2 = null;
+		}
+
+		[Test]
+		public void ObjectToDataRowTest()
+		{
+			DataTable       table = new DataTable();
+			DataRowTestType obj   = new DataRowTestType();
+
+			Map.ObjectToDataRow(obj, table);
+
+			Assert.IsNotEmpty(table.Rows);
+			DataRow dr      = table.Rows[0];
+
+			Assert.AreEqual(table.Columns["Int32Column"]     .DataType, typeof(Int32));
+			Assert.AreEqual(table.Columns["StringColumn"]    .DataType, typeof(String));
+			Assert.AreEqual(table.Columns["ByteArrayColumn"] .DataType, typeof(Byte[]));
+			//Assert.AreEqual(table.Columns["ByteArrayColumn2"].DataType, typeof(Byte[]));
+
+			Assert.AreEqual(obj.Int32Column,      dr["Int32Column"]);
+			Assert.AreEqual(obj.StringColumn,     dr["StringColumn"]);
+			Assert.AreEqual(obj.ByteArrayColumn,  dr["ByteArrayColumn"]);
+			//Assert.AreEqual(obj.ByteArrayColumn2, dr["ByteArrayColumn2"]);
+		}
+
+		#endregion
+
+		class ObjectStr1
+		{
+			public string Field;
+		}
+
+		class ObjectDateTime1
+		{
+			public DateTime Field = DateTime.Now;
+		}
+
+		[Test]
+		public void TestConverter()
+		{
+			var prev = Convert<DateTime,string>.From;
+
+			Convert<DateTime,string>.From = str =>
+				DateTime.ParseExact(str, new[] { "yyyymmdd" }, CultureInfo.InvariantCulture, DateTimeStyles.None);
+
+			var map = Map.GetObjectMapper<List<ObjectStr1>,List<ObjectDateTime1>>();
+			var obj = map(new List<ObjectStr1> { new ObjectStr1 { Field = "20110102" } });
+
+			Assert.That(obj.Count,         Is.EqualTo(1));
+			Assert.That(obj[0].Field.Year, Is.EqualTo(2011));
+
+			Convert<DateTime,string>.From = prev;
+		}
+
+		public abstract class Test
+		{
+			public abstract int Id { get; set; }
+		}
+
+		[Test]
+		public void AccessorTest()
+		{
+			var test     = TypeAccessor<Test>.CreateInstance();
+			var mapper   = Map.GetObjectMapper<Test,Test>();
+			var testCopy = mapper(test);
+		}
+	}
+}