--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/UnitTests/CS/Common/ConvertTest.cs	Thu Mar 27 21:46:09 2014 +0400
@@ -0,0 +1,237 @@
+using System;
+#if ORACLE
+using Oracle.DataAccess.Types;
+#endif
+using System.Reflection;
+using BLToolkit.Common;
+using BLToolkit.Reflection;
+
+using NUnit.Framework;
+
+using Convert = BLToolkit.Common.Convert;
+
+namespace Common
+{
+	[TestFixture]
+	public class ConvertTest
+	{
+		[Test]
+		public void StringTest()
+		{
+			string testStr = "123";
+
+			Assert.AreEqual(123, Convert.ToSByte(testStr));
+			Assert.AreEqual(123, Convert.ToInt16(testStr));
+			Assert.AreEqual(123, Convert.ToInt32(testStr));
+			Assert.AreEqual(123, Convert.ToInt64(testStr));
+
+			Assert.AreEqual(123, Convert.ToByte(testStr));
+			Assert.AreEqual(123, Convert.ToUInt16(testStr));
+			Assert.AreEqual(123, Convert.ToUInt32(testStr));
+			Assert.AreEqual(123, Convert.ToUInt64(testStr));
+
+			Assert.AreEqual(123.0m, Convert.ToDecimal(testStr));
+			Assert.AreEqual(123.0f, Convert.ToSingle(testStr));
+			Assert.AreEqual(123.0,  Convert.ToDouble(testStr));
+
+			string zeroStr = "0";
+
+			Assert.AreEqual(0, Convert.ToSByte((string)null));
+			Assert.AreEqual(0, Convert.ToSByte(zeroStr));
+			Assert.AreEqual(0, Convert.ToInt16(zeroStr));
+			Assert.AreEqual(0, Convert.ToInt32(zeroStr));
+			Assert.AreEqual(0, Convert.ToInt64(zeroStr));
+
+			Assert.AreEqual(0, Convert.ToByte(zeroStr));
+			Assert.AreEqual(0, Convert.ToUInt16(zeroStr));
+			Assert.AreEqual(0, Convert.ToUInt32(zeroStr));
+			Assert.AreEqual(0, Convert.ToUInt64(zeroStr));
+
+			Assert.AreEqual(0.0m, Convert.ToDecimal(zeroStr));
+			Assert.AreEqual(0.0f, Convert.ToSingle(zeroStr));
+			Assert.AreEqual(0.0,  Convert.ToDouble(zeroStr));
+
+			Assert.IsTrue(Convert.ToBoolean("True"));
+			Assert.IsTrue(Convert.ToBoolean("true"));
+
+			Assert.IsFalse(Convert.ToBoolean("false"));
+			Assert.IsFalse(Convert.ToBoolean("FALSE"));
+			Assert.IsFalse(Convert.ToBoolean((string)null));
+
+			Assert.AreEqual('T', Convert.ToChar("T"));
+			Assert.AreEqual(0, Convert.ToChar((string)null));
+
+			Assert.AreEqual(DateTime.Today, Convert.ToDateTime(DateTime.Today.ToString()));
+			Assert.AreEqual(DateTime.MinValue, Convert.ToDateTime((string)null));
+
+			Assert.AreEqual(TimeSpan.FromDays(123.0), Convert.ToTimeSpan("123"));
+			Assert.AreEqual(TimeSpan.MinValue, Convert.ToTimeSpan((string)null));
+
+			Assert.AreEqual(typeof(int).GUID, Convert.ToGuid(typeof(int).GUID.ToString()));
+			Assert.AreEqual(Guid.Empty, Convert.ToGuid((string)null));
+
+			Assert.AreEqual(typeof(int), Convert.ToType("System.Int32, mscorlib"));
+			Assert.IsNull(Convert.ToType((string)null));
+		}
+
+		private static readonly Type[] NumericTypes =
+		{
+            typeof(SByte),
+            typeof(Byte),
+            typeof(Int16),
+            typeof(UInt16),
+            typeof(Int32),
+            typeof(UInt32),
+            typeof(Int64),
+            typeof(UInt64),
+            typeof(Single),
+            typeof(Double),
+            typeof(Decimal),
+        };
+
+		private const BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Static;
+
+		[Test]
+		public void NumericTest()
+		{
+			TypeHelper helper = new TypeHelper(typeof(Convert));
+			IConvertible src  = 123;
+
+			// All types from SByte to Decimal can convert to each other
+			//
+			for (int from = 0; from < NumericTypes.Length; ++from)
+			{
+				Type typeFrom = NumericTypes[from];
+				object   test = src.ToType(typeFrom, null);
+
+				for (int to = 0; to < NumericTypes.Length; ++to)
+				{
+					if (from == to)
+						continue;
+
+					Type   typeTo = NumericTypes[to];
+					MethodInfo mi = helper.GetMethod("To" + typeTo.Name, bindingFlags, typeFrom);
+
+					Assert.IsNotNull(mi, string.Format("Missed To{0}({1})", typeTo.Name, typeFrom.Name));
+					Assert.AreEqual(123, mi.Invoke(null, new object[] { test }));
+				}
+			}
+		}
+
+		[Test]
+		public void DateTimeTest()
+		{
+			Assert.AreEqual(DateTime.MinValue + TimeSpan.FromDays(1), Convert.ToDateTime(1.0));
+			Assert.AreEqual(TimeSpan.FromDays(1), Convert.ToTimeSpan(1.0));
+
+			Assert.AreEqual(DateTime.MinValue + TimeSpan.FromTicks(1), Convert.ToDateTime(1L));
+			Assert.AreEqual(TimeSpan.FromTicks(1), Convert.ToTimeSpan(1L));
+		}
+
+		[Test]
+		public void InterfaceTest()
+		{
+			Assert.AreEqual(123, ConvertTo<IConvertible>.From(123).ToByte(null));
+		}
+
+		[Test]
+		public void EnumTest()
+		{
+			// Enum-to-enum.
+			//
+			Assert.AreEqual(BindingFlags.DeclaredOnly,
+				ConvertTo<BindingFlags>.From(CallingConventions.VarArgs));
+
+			// Enum-to-nullable byte.
+			//
+			Assert.AreEqual((byte?)BindingFlags.DeclaredOnly,
+				ConvertTo<byte?>.From(BindingFlags.DeclaredOnly));
+
+			// Nullable Enum-to-nullable enum.
+			//
+			Assert.AreEqual((CallingConventions?)CallingConventions.VarArgs,
+				ConvertTo<CallingConventions?>.From((BindingFlags?)BindingFlags.DeclaredOnly));
+
+			// Integer-to-enum.
+			//
+			Assert.AreEqual(BindingFlags.DeclaredOnly,
+				ConvertTo<BindingFlags>.From((int)BindingFlags.DeclaredOnly));
+
+			// Integer-to-nullable enum.
+			//
+			Assert.AreEqual(BindingFlags.DeclaredOnly,
+				ConvertTo<BindingFlags?>.From((int)BindingFlags.DeclaredOnly));
+
+		}
+
+		[Test]
+		public void ByteArrayTest()
+		{
+			Byte[] bytes;
+			object value;
+
+			bytes = new byte[] {123};
+			value = (byte)123;
+			Assert.AreEqual(bytes, Convert.ToByteArray(value));
+			Assert.AreEqual(value, Convert.ToByte(bytes));
+
+			bytes = new byte[] {123, 0};
+			value = (short)123;
+			Assert.AreEqual(bytes, Convert.ToByteArray(value));
+			Assert.AreEqual(value, Convert.ToInt16(bytes));
+
+			bytes = new byte[] {210, 2, 150, 73};
+			value = 1234567890;
+			Assert.AreEqual(bytes, Convert.ToByteArray(value));
+			Assert.AreEqual(value, Convert.ToInt32(bytes));
+
+			bytes = new byte[] {(byte) 't', (byte) 's', (byte) 't'};
+			value = "tst";
+			Assert.AreEqual(bytes, Convert.ToByteArray(value));
+			Assert.AreEqual(value, Convert.ToString(bytes));
+
+			bytes = new byte[] {12, 0, 0, 0, 0, 0, 0, 0, 192, 0, 0, 0, 0, 0, 0, 70};
+			value = typeof(System.Runtime.InteropServices.ComTypes.IStream).GUID;
+			Assert.AreEqual(bytes, Convert.ToByteArray(value));
+			Assert.AreEqual(value, Convert.ToGuid(bytes));
+
+			bytes = new byte[] {210, 10, 31, 235, 140, 169, 84, 171, 0, 0, 0, 0, 0, 0, 0, 0};
+			value = 12345678901234567890m;
+			Assert.AreEqual(bytes, Convert.ToByteArray(value));
+			Assert.AreEqual(value, Convert.ToDecimal(bytes));
+
+			bytes = new byte[] {121, 233, 246, 66};
+			value = 123.456f;
+			Assert.AreEqual(bytes, Convert.ToByteArray(value));
+			Assert.AreEqual(value, Convert.ToSingle(bytes));
+
+			bytes = new byte[] {119, 190, 159, 26, 47, 221, 94, 64};
+			value = 123.456;
+			Assert.AreEqual(bytes, Convert.ToByteArray(value));
+			Assert.AreEqual(value, Convert.ToDouble(bytes));
+		}
+
+		[Test]
+		public void ConvertT()
+		{
+			decimal d = ConvertTo<decimal>.From(123);
+			Assert.AreEqual(123.0m, d);
+		}
+
+#if ORACLE
+		[Test]
+		public void TypeCast()
+		{
+			// Note that method BLToolkit.Common.Convert.ToDecimal(OracleNumber p) does not exist.
+			//
+			decimal d = ConvertTo<decimal>.From(new OracleDecimal(123));
+			Assert.AreEqual(123.0m, d);
+
+			// Method BLToolkit.Common.Convert.ToOracleString(string p) does not exist too.
+			//
+			OracleString s = ConvertTo<OracleString>.From("test");
+			Assert.AreEqual("test", s.Value);
+		}
+#endif
+	}
+}