* app-default.config: Renamed to app-net_1_1.config, and added

providerTests section.
* app-net_2.0.config: Added providerTests section and removed
mono.data section.
* Makefile: Added support for CONNECTION variable and corresponding
PROVIDER_TESTS_CONNECTION environment variable. Always rebuild test
assembly since we have no dependency check for sources in place.
Only add reference to Mono.Data on 1.1 profile. Added reference to
System.Configuration on 2.0 profile.
* sqlserver.config: Merged into app-*.config.
* odbc.config: Merged into app-*.config.
* System.Data.Connected.Tests.dll.sources: Added ConnectionConfig.cs,
EngineConfig.cs, EngineType.cs, ProviderTestsConfigurationHandler.cs
and DbDataReaderTest.cs. Removed OdbcConnectionStringBuilderTest.cs.
* ConnectionConfig.cs:  Holds information on a specific connection and
corresponding engine to test.
* EngineConfig.cs: Holds information on the capabilities and behavior
of an RDBMS engine.
* EngineType.cs: Defines different database engines supported by the
provider tests.
* ConnectionManager.cs: Use DbProviderFactory and DbConnection
on 2.0 profile. Added support for new Connection/Engine configuration.
* ProviderTestsConfigurationHandler.cs: IConfigurationSectionHandler
for the ProviderTests section.
* DataReaderTest.cs: Added tests that were previously part of
SqlClient tests but apply to all families. Improved existing
tests.
* DbDataReaderTest.cs: Added GetProviderSpecificValues error check
 tests.
* IDbCommandTest.cs: Added ExecuteNonQuery tests for empty CommandText.
Added test for bug #462947.
* OdbcCommandBuilderTest.cs: Improved GetDeleteCommand,
GetInsertCommand and GetUpdateCommand tests. Added QuotePrefix,
QuoteSuffix and QuoteIdentifier tests.
* OdbcCommandTest.cs: Improved existing tests. Added
ExecuteNonQuery and Dispose tests.
* OdbcConnectionStringBuilderTest.cs: Moved to System.Data
test suite.
* OdbcDataAdapterTest.cs: Removed extra whitespace.
* OdbcDataReaderTest.cs: Added GetBytes and GetSchemaTable
tests.
* OdbcParameterCollectionTest.cs: Improve existing tests.
* OdbcParameterTest.cs: Added tests for several data types.
* SqlCommandBuilderTest.cs: Improve Get*Command tests.
* SqlCommandTest.cs: Added test for bug #341743. Added test
for connection state after executing invalid SQL. Improved
stored procedure test to check behavior with and without
leading '@' for parameter names. Minor formatting changes.
* SqlConnectionTest.cs: Split up connection string errors
test.
* SqlDataReaderTest.cs: Improved GetInt64Test. Improved and
added GetBytes tests. Added GetSqlValues and HasRows tests.
Added GetSchemaTable test. Improved GetProviderSpecificFieldType
tests.
* SqlParameterTest.cs: Improved ParameterType test. Added
type inferrence tests.
* SqlTransactionTest.cs: Allow not working tests to run on MS.
* MySQL_5.sql: Added numeric and decimal colums with different
precision and scale. Added more rows to binary_family. Added
nchar and nvarchar columns to string_family, and added extra
data. Added time and date columns to datetime_family.
* sqlserver.sql: Added numeric and decimal colums with different
precision and scale. Added timestamp column and more rows to
binary_family. Added nchar and nvarchar columns to string_family,
and added extra data. Added sp_326182 stored procedure.
* sybase.sql: Added more rows to binary_family.

svn path=/trunk/mcs/; revision=122297

1 files changed, 4083 insertions, 250 deletions

diff --git a/mcs/class/System.Data/Test/ProviderTests/System.Data.Odbc/OdbcParameterTest.cs b/mcs/class/System.Data/Test/ProviderTests/System.Data.Odbc/OdbcParameterTest.cs
index 66832a3c4d1..55d3625ad2e 100644
--- a/mcs/class/System.Data/Test/ProviderTests/System.Data.Odbc/OdbcParameterTest.cs
+++ b/mcs/class/System.Data/Test/ProviderTests/System.Data.Odbc/OdbcParameterTest.cs
@@ -3,8 +3,9 @@
 //
 // Authors:
 //      Sureshkumar T (TSureshkumar@novell.com)
+//      Gert Driesen (drieseng@users.sourceforge.net)
 // 
-// Copyright (c) 2005 Novell Inc., and the individuals listed
+// Copyright (c) 2005-2008 Novell Inc., and the individuals listed
 // on the ChangeLog entries.
 //
 // Permission is hereby granted, free of charge, to any person obtaining
@@ -32,6 +33,8 @@ using System.Data;
 using System.Data.Common;
 using System.Data.Odbc;
 using System.Globalization;
+using System.Text;
+using System.Threading;
 
 using Mono.Data;
 
@@ -43,87 +46,1026 @@ namespace MonoTests.System.Data
 	[Category ("odbc")]
 	public class OdbcParameterTest
 	{
+		private CultureInfo _originalCulture;
+
+		[SetUp]
+		public void Setup ()
+		{
+			_originalCulture = Thread.CurrentThread.CurrentCulture;
+			Thread.CurrentThread.CurrentCulture = new CultureInfo ("nl-BE");
+		}
+
+		[TearDown]
+		public void TearDown ()
+		{
+			Thread.CurrentThread.CurrentCulture = _originalCulture;
+		}
+
 		[Test]
 		public void IntegerParamTest ()
 		{
-			string query = "select type_int from numeric_family where id = ?";
+			string insert_data = "insert into numeric_family (id, type_int) values (6000, ?)";
+			string select_data = "select id, type_int from numeric_family where type_int = ? and id = ?";
+			string select_by_id = "select id, type_int from numeric_family where id = ?";
+			string delete_data = "delete from numeric_family where id = 6000";
+
 			IDbConnection conn = ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
 			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_int", OdbcType.Int);
+				param.Value = int.MaxValue;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (1, dr.GetValue (0), "#A2");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#A3");
+				Assert.AreEqual (int.MaxValue, dr.GetValue (1), "#A4");
+				Assert.IsFalse (dr.Read (), "#A5");
+				dr.Close ();
+				cmd.Dispose ();
 
-				OdbcParameter param = cmd.Parameters.Add ("id", OdbcType.Int);
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_int", OdbcType.Int);
+				param.Value = int.MinValue;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
 				param.Value = 2;
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (-2147483648, (int) reader [0], "#2 value not matching");
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (2, dr.GetValue (0), "#B2");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#B3");
+				Assert.AreEqual (int.MinValue, dr.GetValue (1), "#B4");
+				Assert.IsFalse (dr.Read (), "#B5");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_int", OdbcType.Int);
+				param.Value = 0;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (3, dr.GetValue (0), "#C2");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#C3");
+				Assert.AreEqual (0, dr.GetValue (1), "#C4");
+				Assert.IsFalse (dr.Read (), "#C5");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (4, dr.GetValue (0), "#D3");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#D4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
+				Assert.IsFalse (dr.Read (), "#D6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_int", OdbcType.Int);
+				param.Value = int.MaxValue;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#E4");
+				Assert.AreEqual (int.MaxValue, dr.GetValue (1), "#E5");
+				Assert.IsFalse (dr.Read (), "#E6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_int", OdbcType.Int);
+				param.Value = int.MinValue;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#F1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#F4");
+				Assert.AreEqual (int.MinValue, dr.GetValue (1), "#F5");
+				Assert.IsFalse (dr.Read (), "#F6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_int", OdbcType.Int);
+				param.Value = 0;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#G4");
+				Assert.AreEqual (0, dr.GetValue (1), "#G5");
+				Assert.IsFalse (dr.Read (), "#G6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_int", OdbcType.Int);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#H1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#H3");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#H4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
+				Assert.IsFalse (dr.Read (), "#H6");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
 		[Test]
 		public void BigIntParamTest ()
 		{
-			string query = "select id, type_bigint from numeric_family where type_bigint = ? and id = 1";
+			string insert_data = "insert into numeric_family (id, type_bigint) values (6000, ?)";
+			string select_data = "select id, type_bigint from numeric_family where type_bigint = ? and id = ?";
+			string select_by_id = "select id, type_bigint from numeric_family where id = ?";
+			string delete_data = "delete from numeric_family where id = 6000";
+
 			IDbConnection conn = ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
 			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
+				param.Value = 9223372036854775807L;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (1, dr.GetValue (0), "#A3");
+				Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#A4");
+				Assert.AreEqual (9223372036854775807L, dr.GetValue (1), "#A5");
+				Assert.IsFalse (dr.Read (), "#A6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
+				param.Value = -9223372036854775808L;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (2, dr.GetValue (0), "#B3");
+				Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#B4");
+				Assert.AreEqual (-9223372036854775808L, dr.GetValue (1), "#B5");
+				Assert.IsFalse (dr.Read (), "#B6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
+				param.Value = 0L;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (3, dr.GetValue (0), "#C3");
+				Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#C4");
+				Assert.AreEqual (0L, dr.GetValue (1), "#C5");
+				Assert.IsFalse (dr.Read (), "#C6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (4, dr.GetValue (0), "#D3");
+				Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#D4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
+				Assert.IsFalse (dr.Read (), "#D6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
+				param.Value = 8223372036854775805L;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
 
-				OdbcParameter param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
-				param.Value = (long) (9223372036854775807);
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (1, Convert.ToInt32 (reader [0]), "#2 value not matching");
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
+				param.Value = 8223372036854775805L;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
+				Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#E4");
+				Assert.AreEqual (8223372036854775805L, dr.GetValue (1), "#E5");
+				Assert.IsFalse (dr.Read (), "#E6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
+				param.Value = -8223372036854775805L;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
+				param.Value = -8223372036854775805L;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#F1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
+				Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#F4");
+				Assert.AreEqual (-8223372036854775805L, dr.GetValue (1), "#F5");
+				Assert.IsFalse (dr.Read (), "#F6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
+				param.Value = 0L;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
+				param.Value = 0;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
+				Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#G4");
+				Assert.AreEqual (0L, dr.GetValue (1), "#G5");
+				Assert.IsFalse (dr.Read (), "#G6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#H1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#H3");
+				Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#H4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
+				Assert.IsFalse (dr.Read (), "#H6");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
+			}
+		}
+
+		[Test]
+		public void BinaryParameterTest ()
+		{
+			string insert_data = "insert into binary_family (id, type_binary) values (6000, ?)";
+			string select_data = "select id, type_binary from binary_family where type_binary = ? and id = ?";
+			string select_by_id = "select id, type_binary from binary_family where id = ?";
+			string delete_data = "delete from binary_family where id = 6000";
+
+			OdbcConnection conn = (OdbcConnection) ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
+			try {
+				byte [] bytes = new byte [] { 0x35, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00 };
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
+				param.Value = bytes;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (1, dr.GetValue (0), "#A3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#A4");
+				Assert.AreEqual (bytes, dr.GetValue (1), "#A5");
+				Assert.IsFalse (dr.Read (), "#A6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				bytes = new byte [] { 0x00, 0x33, 0x34, 0x00,
+					0x33, 0x30, 0x35, 0x31 };
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
+				param.Value = bytes;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (2, dr.GetValue (0), "#B3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#B4");
+				Assert.AreEqual (bytes, dr.GetValue (1), "#B5");
+				Assert.IsFalse (dr.Read (), "#B6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				bytes = new byte [8];
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
+				param.Value = bytes;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (3, dr.GetValue (0), "#C3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#C4");
+				Assert.AreEqual (bytes, dr.GetValue (1), "#C5");
+				Assert.IsFalse (dr.Read (), "#C6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int); 
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (4, dr.GetValue (0), "#D3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#D4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
+				Assert.IsFalse (dr.Read (), "#D6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				bytes = new byte [0];
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
+				param.Value = bytes;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#E4");
+				Assert.AreEqual (new byte [8], dr.GetValue (1), "#E5");
+				Assert.IsFalse (dr.Read (), "#E6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				bytes = new byte [] { 0x05 };
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
+				param.Value = bytes;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#F1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#F4");
+				Assert.AreEqual (new byte [] { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, dr.GetValue (1), "#F5");
+				Assert.IsFalse (dr.Read (), "#F6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				bytes = new byte [] { 0x34, 0x00, 0x32 };
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
+				param.Value = bytes;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#G4");
+				Assert.AreEqual (new byte [] { 0x34, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00 }, dr.GetValue (1), "#G5");
+				Assert.IsFalse (dr.Read (), "#G6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				bytes = new byte [] { 0x34, 0x00, 0x32, 0x05, 0x07, 0x13 };
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_binary", OdbcType.Binary, 4);
+				param.Value = bytes;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#H1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#H3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#H4");
+				Assert.AreEqual (new byte [] { 0x34, 0x00, 0x32, 0x05, 0x00, 0x00, 0x00, 0x00 }, dr.GetValue (1), "#H5");
+				Assert.IsFalse (dr.Read (), "#H6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#I1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#I2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#I3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#I4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#I5");
+				Assert.IsFalse (dr.Read (), "#I6");
+				dr.Close ();
+				cmd.Dispose ();
+			} finally {
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
 		[Test]
 		public void SmallIntParamTest ()
 		{
-			string query = "select id, type_smallint from numeric_family where type_smallint = ? and id = 1";
+			string insert_data = "insert into numeric_family (id, type_smallint) values (6000, ?)";
+			string select_data = "select id, type_smallint from numeric_family where type_smallint = ? and id = ?";
+			string select_by_id = "select id, type_smallint from numeric_family where id = ?";
+			string delete_data = "delete from numeric_family where id = 6000";
+
 			IDbConnection conn = ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
 			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
+				param.Value = short.MaxValue;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (1, dr.GetValue (0), "#A2");
+				Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#A3");
+				Assert.AreEqual (short.MaxValue, dr.GetValue (1), "#A4");
+				Assert.IsFalse (dr.Read (), "#A5");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
+				param.Value = short.MinValue;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (2, dr.GetValue (0), "#B2");
+				Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#B3");
+				Assert.AreEqual (short.MinValue, dr.GetValue (1), "#B4");
+				Assert.IsFalse (dr.Read (), "#B5");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
+				param.Value = (short) 0;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (3, dr.GetValue (0), "#C2");
+				Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#C3");
+				Assert.AreEqual (0, dr.GetValue (1), "#C4");
+				Assert.IsFalse (dr.Read (), "#C5");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (4, dr.GetValue (0), "#D3");
+				Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#D4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
+				Assert.IsFalse (dr.Read (), "#D6");
+				dr.Close ();
+				cmd.Dispose ();
 
-				OdbcParameter param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
-				param.Value = 32767;
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (1, Convert.ToInt32 (reader [0]), "#2 value not matching");
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
+				param.Value = short.MaxValue;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
+				Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#E4");
+				Assert.AreEqual (short.MaxValue, dr.GetValue (1), "#E5");
+				Assert.IsFalse (dr.Read (), "#E6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
+				param.Value = short.MinValue;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#F1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
+				Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#F4");
+				Assert.AreEqual (short.MinValue, dr.GetValue (1), "#F5");
+				Assert.IsFalse (dr.Read (), "#F6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
+				param.Value = 0;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
+				Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#G4");
+				Assert.AreEqual ((short) 0, dr.GetValue (1), "#G5");
+				Assert.IsFalse (dr.Read (), "#G6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#H1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#H3");
+				Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#H4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
+				Assert.IsFalse (dr.Read (), "#H6");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
+			}
+		}
+
+		[Test]
+		public void TimestampParameterTest ()
+		{
+			// the value for the timestamp column is determined by
+			// the RDBMS upon insert/update and cannot be specified
+			// by the user
+
+			string insert_data = "insert into binary_family (id) values (6000)";
+			string select_by_id = "select id, type_timestamp from binary_family where id = ?";
+			string delete_data = "delete from binary_family where id = 6000";
+
+			OdbcConnection conn = (OdbcConnection) ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
+			try {
+				if (!ConnectionManager.Singleton.Engine.SupportsTimestamp)
+					Assert.Ignore ("Timestamp test does not apply to the current driver (" + conn.Driver + ").");
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				byte [] timestamp;
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = "SELECT @@DBTS";
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#A2");
+				timestamp = (byte []) dr.GetValue (0);
+				Assert.IsFalse (dr.Read (), "#A3");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#B3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#B4");
+				Assert.AreEqual (timestamp, dr.GetValue (1), "#B5");
+				Assert.IsFalse (dr.Read (), "#B6");
+				dr.Close ();
+				cmd.Dispose ();
+			} finally {
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
 		[Test]
 		public void TinyIntParamTest ()
 		{
-			string query = "select id, type_tinyint from numeric_family where type_tinyint = ? and id = 1";
+			string insert_data = "insert into numeric_family (id, type_tinyint) values (6000, ?)";
+			string select_data = "select id, type_tinyint from numeric_family where type_tinyint = ? and id = ?";
+			string select_by_id = "select id, type_tinyint from numeric_family where id = ?";
+			string delete_data = "delete from numeric_family where id = 6000";
+
 			IDbConnection conn = ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
 			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
+				param.Value = byte.MaxValue;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (1, dr.GetValue (0), "#A2");
+				Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#A3");
+				Assert.AreEqual (byte.MaxValue, dr.GetValue (1), "#A4");
+				Assert.IsFalse (dr.Read (), "#A5");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
+				param.Value = byte.MinValue;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (2, dr.GetValue (0), "#B2");
+				Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#B3");
+				Assert.AreEqual (byte.MinValue, dr.GetValue (1), "#B4");
+				Assert.IsFalse (dr.Read (), "#B5");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
+				param.Value = 0x00;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (3, dr.GetValue (0), "#C2");
+				Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#C3");
+				Assert.AreEqual (0x00, dr.GetValue (1), "#C4");
+				Assert.IsFalse (dr.Read (), "#C5");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (4, dr.GetValue (0), "#D3");
+				Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#D4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
+				Assert.IsFalse (dr.Read (), "#D6");
+				dr.Close ();
+				cmd.Dispose ();
 
-				OdbcParameter param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
-				param.Value = 255;
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (1, Convert.ToInt32 (reader [0]), "#2 value not matching");
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
+				param.Value = byte.MaxValue;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
+				Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#E4");
+				Assert.AreEqual (byte.MaxValue, dr.GetValue (1), "#E5");
+				Assert.IsFalse (dr.Read (), "#E6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
+				param.Value = byte.MinValue;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#F1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
+				Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#F4");
+				Assert.AreEqual (byte.MinValue, dr.GetValue (1), "#F5");
+				Assert.IsFalse (dr.Read (), "#F6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
+				param.Value = 0x00;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
+				Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#G4");
+				Assert.AreEqual (0x00, dr.GetValue (1), "#G5");
+				Assert.IsFalse (dr.Read (), "#G6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#H1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#H3");
+				Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#H4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
+				Assert.IsFalse (dr.Read (), "#H6");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
-
 		[Test]
 		public void StringParamTest ()
 		{
@@ -136,9 +1078,9 @@ namespace MonoTests.System.Data
 
 				OdbcParameter param = cmd.Parameters.Add ("fname", OdbcType.VarChar);
 				param.Value = "suresh";
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (1, (int) reader [0], "#2 value not matching");
+				OdbcDataReader dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#1 no data to test");
+				Assert.AreEqual (1, (int) dr [0], "#2 value not matching");
 			} finally {
 				ConnectionManager.Singleton.CloseConnection ();
 			}
@@ -148,316 +1090,3153 @@ namespace MonoTests.System.Data
 		[Test]
 		public void BitParameterTest ()
 		{
-			string query = "select id, type_bit from numeric_family where type_bit = ? and id = 1";
+			string insert_data = "insert into numeric_family (id, type_bit) values (6000, ?)";
+			string select_data = "select id, type_bit from numeric_family where type_bit = ? and id = ?";
+			string select_by_id = "select id, type_bit from numeric_family where id = ?";
+			string delete_data = "delete from numeric_family where id = 6000";
+
 			IDbConnection conn = ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
 			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
+				param.Value = true;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (1, dr.GetValue (0), "#A2");
+				Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#A3");
+				Assert.AreEqual (true, dr.GetValue (1), "#A4");
+				Assert.IsFalse (dr.Read (), "#A5");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
+				param.Value = false;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (2, dr.GetValue (0), "#B2");
+				Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#B3");
+				if (ConnectionManager.Singleton.Engine.Type == EngineType.MySQL)
+					// MySQL does not support true BIT type
+					Assert.AreEqual (true, dr.GetValue (1), "#B4");
+				else
+					Assert.AreEqual (false, dr.GetValue (1), "#B4");
+				Assert.IsFalse (dr.Read (), "#B5");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (4, dr.GetValue (0), "#C3");
+				Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#C4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#C5");
+				Assert.IsFalse (dr.Read (), "#C6");
+				dr.Close ();
+				cmd.Dispose ();
 
-				OdbcParameter param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
 				param.Value = true;
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (1, Convert.ToInt32 (reader [0]), "#2 value not matching");
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
+				param.Value = true;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#D3");
+				Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#D4");
+				Assert.AreEqual (true, dr.GetValue (1), "#D5");
+				Assert.IsFalse (dr.Read (), "#D6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
+				param.Value = false;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
+				param.Value = false;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
+				Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#E4");
+				if (ConnectionManager.Singleton.Engine.Type == EngineType.MySQL)
+					// MySQL does not support true BIT type
+					Assert.AreEqual (true, dr.GetValue (1), "#E5");
+				else
+					Assert.AreEqual (false, dr.GetValue (1), "#E5");
+				Assert.IsFalse (dr.Read (), "#E6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#F1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
+				Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#F4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#F5");
+				Assert.IsFalse (dr.Read (), "#F6");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
 		[Test]
 		public void CharParameterTest ()
 		{
-			string query = "select id, type_char from string_family where type_char = ? and id = 1";
-			IDbConnection conn = ConnectionManager.Singleton.Connection;
-			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+			string insert_data = "insert into string_family (id, type_char) values (6000, ?)";
+			string select_data = "select id, type_char from string_family where type_char = ? and id = ?";
+			string select_by_id = "select id, type_char from string_family where id = ?";
+			string delete_data = "delete from string_family where id = 6000";
 
-				OdbcParameter param = cmd.Parameters.Add ("type_char", OdbcType.Char);
+			OdbcConnection conn = (OdbcConnection) ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
+			try {
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_char", OdbcType.Char);
 				param.Value = "char";
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (1, Convert.ToInt32 (reader [0]), "#2 value not matching");
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (1, dr.GetValue (0), "#A3");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#A4");
+				if (ConnectionManager.Singleton.Engine.RemovesTrailingSpaces)
+					Assert.AreEqual ("char", dr.GetValue (1), "#A5");
+				else
+					Assert.AreEqual ("char      ", dr.GetValue (1), "#A5");
+				Assert.IsFalse (dr.Read (), "#A6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_char", OdbcType.Char);
+				param.Value = "0123456789";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (2, dr.GetValue (0), "#B3");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#B4");
+				Assert.AreEqual ("0123456789", dr.GetValue (1), "#B5");
+				Assert.IsFalse (dr.Read (), "#B6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_char", OdbcType.Char);
+				param.Value = string.Empty;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (3, dr.GetValue (0), "#C3");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#C4");
+				if (ConnectionManager.Singleton.Engine.RemovesTrailingSpaces)
+					Assert.AreEqual (string.Empty, dr.GetValue (1), "#C5");
+				else
+					Assert.AreEqual ("          ", dr.GetValue (1), "#C5");
+				Assert.IsFalse (dr.Read (), "#C6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (4, dr.GetValue (0), "#D3");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#D4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
+				Assert.IsFalse (dr.Read (), "#D6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_char", OdbcType.Char, 3);
+				param.Value = "ABCD";
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_char", OdbcType.Char, 3);
+				param.Value = "ABCE ";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#E4");
+				if (ConnectionManager.Singleton.Engine.RemovesTrailingSpaces)
+					Assert.AreEqual ("ABC", dr.GetValue (1), "#E5");
+				else
+					Assert.AreEqual ("ABC       ", dr.GetValue (1), "#E5");
+				Assert.IsFalse (dr.Read (), "#E6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_char", OdbcType.Char, 20);
+				param.Value = "ABCDEFGHIJ";
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_char", OdbcType.Char);
+				param.Value = "ABCDEFGHIJ";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#F1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#F4");
+				Assert.AreEqual ("ABCDEFGHIJ", dr.GetValue (1), "#F5");
+				Assert.IsFalse (dr.Read (), "#F6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_char", OdbcType.Char, 20);
+				param.Value = string.Empty;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_char", OdbcType.Char);
+				param.Value = string.Empty;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#G4");
+				if (ConnectionManager.Singleton.Engine.RemovesTrailingSpaces)
+					Assert.AreEqual (string.Empty, dr.GetValue (1), "#G5");
+				else
+					Assert.AreEqual ("          ", dr.GetValue (1), "#G5");
+				Assert.IsFalse (dr.Read (), "#G6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_char", OdbcType.Char);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#H1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
+				Assert.AreEqual (4, dr.GetValue (0), "#H3");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#H4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
+				Assert.IsFalse (dr.Read (), "#H6");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
 		[Test]
 		public void DecimalParameterTest ()
 		{
-			string query = "select id, type_decimal from numeric_family where type_decimal = ? and id = 1";
+			string select_data1 = "select id, type_decimal1 from numeric_family where type_decimal1 = ? and id = ?";
+			string select_data2 = "select id, type_decimal2 from numeric_family where type_decimal2 = ? and id = ?";
+			string select_by_id = "select id, type_decimal1, type_decimal2 from numeric_family where id = ?";
+			string insert_data = "insert into numeric_family (id, type_decimal1, type_decimal2) values (6000, ?, ?)";
+			string delete_data = "delete from numeric_family where id = 6000";
+
 			IDbConnection conn = ConnectionManager.Singleton.Connection;
-			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
 
-				OdbcParameter param = cmd.Parameters.Add ("type_decimal", OdbcType.Decimal);
+			try {
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data1;
+				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
 				param.Value = 1000.00m;
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (1, Convert.ToInt32 (reader [0]), "#2 value not matching");
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (1, dr.GetValue (0), "#A3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#A4");
+				Assert.AreEqual (1000m, dr.GetValue (1), "#A5");
+				Assert.IsFalse (dr.Read (), "#A6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data1;
+				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
+				param.Value = -1000.00m;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (2, dr.GetValue (0), "#B3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#B4");
+				Assert.AreEqual (-1000m, dr.GetValue (1), "#B5");
+				Assert.IsFalse (dr.Read (), "#B6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data2;
+				param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
+				param.Value = 4456.432m;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (1, dr.GetValue (0), "#C3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#C4");
+				Assert.AreEqual (4456.432m, dr.GetValue (1), "#C5");
+				Assert.IsFalse (dr.Read (), "#C6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data2;
+				param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
+				param.Value = -4456.432m;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (2, dr.GetValue (0), "#D3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#D4");
+				Assert.AreEqual (-4456.432m, dr.GetValue (1), "#D5");
+				Assert.IsFalse (dr.Read (), "#D6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data1;
+				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
+				param.Value = 0m;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual (3, dr.GetValue (0), "#E3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#E4");
+				Assert.AreEqual (0m, dr.GetValue (1), "#E5");
+				Assert.IsFalse (dr.Read (), "#E6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data1;
+				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
+				param.Value = DBNull.Value;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsFalse (dr.Read (), "#F");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
+				Assert.AreEqual (4, dr.GetValue (0), "#G3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#G4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#G5");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#G6");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (2), "#G7");
+				Assert.IsFalse (dr.Read (), "#G8");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
+				param.Value = -1000.5678m;
+				param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
+				param.Value = -1000.5678m;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data1;
+				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
+				param.Value = -1000.5678m;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsFalse (dr.Read (), "#H");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data1;
+				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
+				param.Value = -1001;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#I1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#I2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#I3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#I4");
+				Assert.AreEqual (-1001m, dr.GetValue (1), "#I5");
+				Assert.IsFalse (dr.Read (), "#I6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data2;
+				param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
+				param.Value = -1000.5678m;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsFalse (dr.Read (), "#J");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data2;
+				param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
+				param.Value = -1000.568m;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#K1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#K2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#K3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#K4");
+				Assert.AreEqual (-1000.568m, dr.GetValue (1), "#K5");
+				Assert.IsFalse (dr.Read (), "#K6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
+				param.Value = 56789m;
+				param.Precision = 7;
+				param.Scale = 2;
+				param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
+				param.Value = 98765.5678m;
+				param.Precision = 10;
+				param.Scale = 2;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#L1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#L2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#L3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#L4");
+				Assert.AreEqual (56789m, dr.GetValue (1), "#L5");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#L6");
+				if (ConnectionManager.Singleton.Engine.Type == EngineType.MySQL)
+					Assert.AreEqual (9876556.780m, dr.GetValue (2), "#L7");
+				else
+					Assert.AreEqual (98765.570m, dr.GetValue (2), "#L7");
+				Assert.IsFalse (dr.Read (), "#L8");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
+				param.Value = DBNull.Value;
+				param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#M1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#M2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#M3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#M4");
+				if (ConnectionManager.Singleton.Engine.Type == EngineType.MySQL)
+					Assert.AreEqual (0m, dr.GetValue (1), "#M5");
+				else
+					Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#M5");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#M6");
+				if (ConnectionManager.Singleton.Engine.Type == EngineType.MySQL)
+					Assert.AreEqual (0m, dr.GetValue (1), "#M7");
+				else
+					Assert.AreEqual (DBNull.Value, dr.GetValue (2), "#M7");
+				Assert.IsFalse (dr.Read (), "#M8");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
+				if (cmd != null)
+					cmd.Dispose ();
+				if (dr != null)
+					dr.Close ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 		
 		[Test]
 		public void DoubleParameterTest ()
 		{
-			string query = "select id, type_double from numeric_family where type_double = ? and id = 1";
+			string insert_data = "insert into numeric_family (id, type_double) values (6000, ?)";
+			string select_data = "select id, type_double from numeric_family where type_double = ? and id = ?";
+			string select_by_id = "select id, type_double from numeric_family where id = ?";
+			string delete_data = "delete from numeric_family where id = 6000";
+
 			IDbConnection conn = ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
 			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
+				param.Value = 1.79E+308;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (1, dr.GetValue (0), "#A3");
+				Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#A4");
+				Assert.AreEqual (1.79E+308, dr.GetValue (1), "#A5");
+				Assert.IsFalse (dr.Read (), "#A6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
+				param.Value = -1.79E+308;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (2, dr.GetValue (0), "#B3");
+				Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#B4");
+				Assert.AreEqual (-1.79E+308, dr.GetValue (1), "#B5");
+				Assert.IsFalse (dr.Read (), "#B6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
+				param.Value = 0d;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (3, dr.GetValue (0), "#C3");
+				Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#C4");
+				Assert.AreEqual (0d, dr.GetValue (1), "#C5");
+				Assert.IsFalse (dr.Read (), "#C6");
+				dr.Close ();
+				cmd.Dispose ();
 
-				OdbcParameter param = cmd.Parameters.Add ("type_double", OdbcType.Double);
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (4, dr.GetValue (0), "#D3");
+				Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#D4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
+				Assert.IsFalse (dr.Read (), "#D6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
+				param.Value = 1.79E+308;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
 				param.Value = 1.79E+308;
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (1, Convert.ToInt32 (reader [0]), "#2 value not matching");
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
+				Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#E4");
+				Assert.AreEqual (1.79E+308, dr.GetValue (1), "#E5");
+				Assert.IsFalse (dr.Read (), "#E6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
+				param.Value = -1.79E+308;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
+				param.Value = -1.79E+308;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#F1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
+				Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#F4");
+				Assert.AreEqual (-1.79E+308, dr.GetValue (1), "#F5");
+				Assert.IsFalse (dr.Read (), "#F6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
+				param.Value = "45543,55";
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
+				param.Value = "45543,55";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
+				Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#G4");
+				Assert.AreEqual (45543.55d, dr.GetValue (1), "#G5");
+				Assert.IsFalse (dr.Read (), "#G6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#H1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#H3");
+				Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#H4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
+				Assert.IsFalse (dr.Read (), "#H6");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
 		[Test]
 		public void ImageParameterTest ()
 		{
-			string query = "insert into binary_family (id, type_blob) values (6000,?)";
+			string insert_data = "insert into binary_family (id, type_blob) values (6000, ?)";
+			string select_data = "select type_blob from binary_family where id = ?";
+			string delete_data = "delete from binary_family where id = 6000";
+
 			IDbConnection conn = ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
 			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+				byte [] bytes = new byte [] { 0x32, 0x56, 0x00,
+					0x44, 0x22 };
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (bytes, dr.GetValue (0), "#A3");
+				Assert.IsFalse (dr.Read (), "#A4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				bytes = new byte [] { 0x00, 0x66, 0x06, 0x66,
+					0x97, 0x00, 0x66, 0x06, 0x66, 0x97, 0x06,
+					0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
+					0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
+					0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
+					0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
+					0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
+					0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
+					0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
+					0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
+					0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
+					0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
+					0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
+					0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
+					0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
+					0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
+					0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
+					0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
+					0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
+					0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
+					0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
+					0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
+					0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
+					0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
+					0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
+					0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
+					0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
+					0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
+					0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
+					0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
+					0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
+					0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
+					0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
+					0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
+					0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
+					0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
+					0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
+					0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
+					0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
+					0x06, 0x66, 0x06, 0x66, 0x98};
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (bytes, dr.GetValue (0), "#B3");
+				Assert.IsFalse (dr.Read (), "#B4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				bytes = new byte [8];
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (new byte [0], dr.GetValue (0), "#C3");
+				Assert.IsFalse (dr.Read (), "#C4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
+				Assert.IsFalse (dr.Read (), "#D4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				bytes = new byte [0];
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_blob", OdbcType.Image);
+				param.Value = bytes;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual (bytes, dr.GetValue (0), "#E3");
+				Assert.IsFalse (dr.Read (), "#E4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				bytes = new byte [] { 0x05 };
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_blob", OdbcType.Image);
+				param.Value = bytes;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#F1");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#F2");
+				Assert.AreEqual (bytes, dr.GetValue (0), "#F3");
+				Assert.IsFalse (dr.Read (), "#F4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				bytes = new byte [] { 0x34, 0x00, 0x32 };
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_blob", OdbcType.Image);
+				param.Value = bytes;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#G2");
+				Assert.AreEqual (bytes, dr.GetValue (0), "#G3");
+				Assert.IsFalse (dr.Read (), "#G4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
 
-				OdbcParameter param = cmd.Parameters.Add ("type_blob", OdbcType.Image);
-				param.Value = new byte [] { 6, 6, 6, 6, 6, 6, 6, 6 };
+				bytes = new byte [] { 0x34, 0x00, 0x32, 0x05, 0x07, 0x13 };
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_blob", OdbcType.Image, 4);
+				param.Value = bytes;
 				cmd.ExecuteNonQuery ();
-				cmd.CommandText = "select count(*) from binary_family where id = 6000";
-				Object count = cmd.ExecuteScalar ();
-				Assert.AreEqual (1, Int32.Parse ((string)count), "#1 value not matching");
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#H1");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#H2");
+				Assert.AreEqual (new byte [] { 0x34, 0x00, 0x32, 0x05 }, dr.GetValue (0), "#H3");
+				Assert.IsFalse (dr.Read (), "#H4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_blob", OdbcType.Image);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#I1");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#I2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#I3");
+				Assert.IsFalse (dr.Read (), "#I4");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
-				ConnectionManager.Singleton.OpenConnection ();
-				DBHelper.ExecuteNonQuery (conn, "delete from binary_family where id = 6000");
-				ConnectionManager.Singleton.CloseConnection ();
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
 		[Test]
 		public void NCharParameterTest ()
 		{
-			string query = "select id, type_char from string_family where type_char = ? and id = 1";
-			IDbConnection conn = ConnectionManager.Singleton.Connection;
+			string insert_data = "insert into string_family (id, type_nchar) values (6000, ?)";
+			string select_data = "select type_nchar from string_family where type_nchar = ? and id = ?";
+			string select_by_id = "select type_nchar from string_family where id = ?";
+			string delete_data = "delete from string_family where id = 6000";
+			
+			OdbcConnection conn = (OdbcConnection) ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
 			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
+				param.Value = "nch\u092d\u093er";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#A2");
+				if (ConnectionManager.Singleton.Engine.RemovesTrailingSpaces)
+					Assert.AreEqual ("nch\u092d\u093er", dr.GetValue (0), "#A3");
+				else
+					Assert.AreEqual ("nch\u092d\u093er    ", dr.GetValue (0), "#A3");
+				Assert.IsFalse (dr.Read (), "#A4");
+				dr.Close ();
+				cmd.Dispose ();
 
-				OdbcParameter param = cmd.Parameters.Add ("type_char", OdbcType.NChar);
-				param.Value = "char";
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (1, Convert.ToInt32 (reader [0]), "#2 value not matching");
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
+				param.Value = "0123456789";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual ("0123456789", dr.GetValue (0), "#B3");
+				Assert.IsFalse (dr.Read (), "#B4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
+				param.Value = string.Empty;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#C2");
+				if (ConnectionManager.Singleton.Engine.RemovesTrailingSpaces)
+					Assert.AreEqual (string.Empty, dr.GetValue (0), "#C3");
+				else
+					Assert.AreEqual ("          ", dr.GetValue (0), "#C3");
+				Assert.IsFalse (dr.Read (), "#C4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
+				Assert.IsFalse (dr.Read (), "#D4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
+				param.Value = "nchar";
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
+				param.Value = "nchar";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#E2");
+				if (ConnectionManager.Singleton.Engine.RemovesTrailingSpaces)
+					Assert.AreEqual ("nchar", dr.GetValue (0), "#E3");
+				else
+					Assert.AreEqual ("nchar     ", dr.GetValue (0), "#E3");
+				Assert.IsFalse (dr.Read (), "#E4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar, 4);
+				param.Value = "nch\u0488r";
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar, 4);
+				param.Value = "nch\u0488r";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#F1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#F2");
+				if (ConnectionManager.Singleton.Engine.RemovesTrailingSpaces)
+					Assert.AreEqual ("nch\u0488", dr.GetValue (0), "#F3");
+				else
+					Assert.AreEqual ("nch\u0488      ", dr.GetValue (0), "#F3");
+				Assert.IsFalse (dr.Read (), "#F4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar, 8);
+				param.Value = "ch\u0488r";
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
+				param.Value = "ch\u0488r";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#G2");
+				if (ConnectionManager.Singleton.Engine.RemovesTrailingSpaces)
+					Assert.AreEqual ("ch\u0488r", dr.GetValue (0), "#G3");
+				else
+					Assert.AreEqual ("ch\u0488r      ", dr.GetValue (0), "#G3");
+				Assert.IsFalse (dr.Read (), "#G4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar, 15);
+				param.Value = "0123456789";
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
+				param.Value = "0123456789";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#H1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#H2");
+				Assert.AreEqual ("0123456789", dr.GetValue (0), "#H3");
+				Assert.IsFalse (dr.Read (), "#H4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar, 15);
+				param.Value = string.Empty;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
+				param.Value = string.Empty;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#I1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#I2");
+				if (ConnectionManager.Singleton.Engine.RemovesTrailingSpaces)
+					Assert.AreEqual (string.Empty, dr.GetValue (0), "#I3");
+				else
+					Assert.AreEqual ("          ", dr.GetValue (0), "#I3");
+				Assert.IsFalse (dr.Read (), "#I4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#J1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#J2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#J3");
+				Assert.IsFalse (dr.Read (), "#J4");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();;
 			}
 		}
 
 		[Test]
 		public void NTextParameterTest ()
 		{
-			string query = "insert into string_family (id, type_ntext) values (6000, ?)";
-			IDbConnection conn = ConnectionManager.Singleton.Connection;
+			string insert_data = "insert into string_family (id, type_ntext) values (6000, ?)";
+			string select_by_id = "select type_ntext from string_family where id = ?";
+			string delete_data = "delete from string_family where id = 6000";
+
+			OdbcConnection conn = (OdbcConnection) ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
 			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual ("nt\u092d\u093ext", dr.GetValue (0), "#A3");
+				Assert.IsFalse (dr.Read (), "#A4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual ("nt\u092d\u093ext ", dr.GetValue (0), "#B3");
+				Assert.IsFalse (dr.Read (), "#B4");
+				dr.Close ();
+				cmd.Dispose ();
 
-				OdbcParameter param = cmd.Parameters.Add ("type_ntext", OdbcType.NText);
-				param.Value = "ntext";
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (string.Empty, dr.GetValue (0), "#C3");
+				Assert.IsFalse (dr.Read (), "#C4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
+				Assert.IsFalse (dr.Read (), "#D4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_ntext", OdbcType.NText, 4);
+				param.Value = "nt\u0488xt";
 				cmd.ExecuteNonQuery ();
-				cmd.CommandText = "select count(*) from string_family where id = 6000";
-				Object count = cmd.ExecuteScalar ();
-				Assert.AreEqual (1, Int32.Parse ((string)count), "#1 value not matching");
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual ("nt\u0488x", dr.GetValue (0), "#E3");
+				Assert.IsFalse (dr.Read (), "#E4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_ntext", OdbcType.NText, 15);
+				param.Value = "nt\u0488xt ";
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#F1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#F2");
+				Assert.AreEqual ("nt\u0488xt ", dr.GetValue (0), "#F3");
+				Assert.IsFalse (dr.Read (), "#F4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_ntext", OdbcType.NText, 8);
+				param.Value = string.Empty;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#G2");
+				Assert.AreEqual (string.Empty, dr.GetValue (0), "#G3");
+				Assert.IsFalse (dr.Read (), "#G4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_ntext", OdbcType.NText, 8);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#H1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#H2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#H3");
+				Assert.IsFalse (dr.Read (), "#H4");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
-				ConnectionManager.Singleton.OpenConnection ();
-				DBHelper.ExecuteNonQuery (conn, "delete from string_family where id = 6000");
-				ConnectionManager.Singleton.CloseConnection ();
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
 		[Test]
 		public void TextParameterTest ()
 		{
-			string query = "insert into string_family (id, type_text) values (6000, ?)";
-			IDbConnection conn = ConnectionManager.Singleton.Connection;
+			string insert_data = "insert into string_family (id, type_text) values (6000, ?)";
+			string select_by_id = "select type_text from string_family where id = ?";
+			string delete_data = "delete from string_family where id = 6000";
+
+			OdbcConnection conn = (OdbcConnection) ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
 			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual ("text", dr.GetValue (0), "#A3");
+				Assert.IsFalse (dr.Read (), "#A4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				StringBuilder sb = new StringBuilder ();
+				for (int i = 0; i < 30; i++)
+					sb.Append ("longtext ");
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (sb.ToString (), dr.GetValue (0), "#B3");
+				Assert.IsFalse (dr.Read (), "#B4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (string.Empty, dr.GetValue (0), "#C3");
+				Assert.IsFalse (dr.Read (), "#C4");
+				dr.Close ();
+				cmd.Dispose ();
 
-				OdbcParameter param = cmd.Parameters.Add ("type_text", OdbcType.Text);
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
+				Assert.IsFalse (dr.Read (), "#D4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_text", OdbcType.Text);
+				param.Value = sb.ToString ();
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual (sb.ToString (), dr.GetValue (0), "#E3");
+				Assert.IsFalse (dr.Read (), "#E4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_text", OdbcType.Text, 2);
 				param.Value = "text";
 				cmd.ExecuteNonQuery ();
-				cmd.CommandText = "select count(*) from string_family where id = 6000";
-				Object count = cmd.ExecuteScalar ();
-				Assert.AreEqual (1, Int32.Parse ((string)count), "#1 value not matching");
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#F1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#F2");
+				Assert.AreEqual ("te", dr.GetValue (0), "#F3");
+				Assert.IsFalse (dr.Read (), "#F4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_text", OdbcType.Text, 8);
+				param.Value = string.Empty;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#G2");
+				Assert.AreEqual (string.Empty, dr.GetValue (0), "#G3");
+				Assert.IsFalse (dr.Read (), "#G4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_text", OdbcType.Text, 8);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#H1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#H2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#H3");
+				Assert.IsFalse (dr.Read (), "#H4");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
-				ConnectionManager.Singleton.OpenConnection ();
-				DBHelper.ExecuteNonQuery (conn, "delete from string_family where id = 6000");
-				ConnectionManager.Singleton.CloseConnection ();
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
 		[Test]
 		public void NumericParameterTest ()
 		{
-			string query = "select id, type_numeric from numeric_family where type_numeric = ? and id = 1";
+			string select_data1 = "select id, type_numeric1 from numeric_family where type_numeric1 = ? and id = ?";
+			string select_data2 = "select id, type_numeric2 from numeric_family where type_numeric2 = ? and id = ?";
+			string select_by_id = "select id, type_numeric1, type_numeric2 from numeric_family where id = ?";
+			string insert_data = "insert into numeric_family (id, type_numeric1, type_numeric2) values (6000, ?, ?)";
+			string delete_data = "delete from numeric_family where id = 6000";
+
 			IDbConnection conn = ConnectionManager.Singleton.Connection;
-			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
 
-				OdbcParameter param = cmd.Parameters.Add ("type_numeric", OdbcType.Numeric);
-				param.Precision = 0;
-				param.Scale = 0;
+			try {
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data1;
+				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
 				param.Value = 1000.00m;
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (1, Convert.ToInt32 (reader [0]), "#2 value not matching");
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (1, dr.GetValue (0), "#A3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#A4");
+				Assert.AreEqual (1000m, dr.GetValue (1), "#A5");
+				Assert.IsFalse (dr.Read (), "#A6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data1;
+				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
+				param.Value = -1000.00m;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (2, dr.GetValue (0), "#B3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#B4");
+				Assert.AreEqual (-1000m, dr.GetValue (1), "#B5");
+				Assert.IsFalse (dr.Read (), "#B6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data2;
+				param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
+				param.Value = 4456.432m;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (1, dr.GetValue (0), "#C3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#C4");
+				Assert.AreEqual (4456.432m, dr.GetValue (1), "#C5");
+				Assert.IsFalse (dr.Read (), "#C6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data2;
+				param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
+				param.Value = -4456.432m;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (2, dr.GetValue (0), "#D3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#D4");
+				Assert.AreEqual (-4456.432m, dr.GetValue (1), "#D5");
+				Assert.IsFalse (dr.Read (), "#D6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data1;
+				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
+				param.Value = 0m;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual (3, dr.GetValue (0), "#E3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#E4");
+				Assert.AreEqual (0m, dr.GetValue (1), "#E5");
+				Assert.IsFalse (dr.Read (), "#E6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data1;
+				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
+				param.Value = DBNull.Value;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsFalse (dr.Read (), "#F");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
+				Assert.AreEqual (4, dr.GetValue (0), "#G3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#G4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#G5");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#G6");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (2), "#G7");
+				Assert.IsFalse (dr.Read (), "#G8");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
+				param.Value = -1000.5678m;
+				param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
+				param.Value = -1000.5678m;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data1;
+				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
+				param.Value = -1000.5678m;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsFalse (dr.Read (), "#H");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data1;
+				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
+				param.Value = -1001;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#I1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#I2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#I3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#I4");
+				Assert.AreEqual (-1001m, dr.GetValue (1), "#I5");
+				Assert.IsFalse (dr.Read (), "#I6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data2;
+				param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
+				param.Value = -1000.5678m;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsFalse (dr.Read (), "#J");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data2;
+				param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
+				param.Value = -1000.568m;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#K1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#K2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#K3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#K4");
+				Assert.AreEqual (-1000.568m, dr.GetValue (1), "#K5");
+				Assert.IsFalse (dr.Read (), "#K6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
+				param.Value = 56789m;
+				param.Precision = 7;
+				param.Scale = 2;
+				param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
+				param.Value = 98765.5678m;
+				param.Precision = 10;
+				param.Scale = 2;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#L1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#L2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#L3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#L4");
+				Assert.AreEqual (56789m, dr.GetValue (1), "#L5");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#L6");
+				if (ConnectionManager.Singleton.Engine.Type == EngineType.MySQL)
+					Assert.AreEqual (9876556.780m, dr.GetValue (2), "#L7");
+				else
+					Assert.AreEqual (98765.570m, dr.GetValue (2), "#L7");
+				Assert.IsFalse (dr.Read (), "#L8");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
+				param.Value = DBNull.Value;
+				param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#M1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#M2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#M3");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#M4");
+				if (ConnectionManager.Singleton.Engine.Type == EngineType.MySQL)
+					Assert.AreEqual (0m, dr.GetValue (1), "#M5");
+				else
+					Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#M5");
+				Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#M6");
+				if (ConnectionManager.Singleton.Engine.Type == EngineType.MySQL)
+					Assert.AreEqual (0m, dr.GetValue (1), "#M7");
+				else
+					Assert.AreEqual (DBNull.Value, dr.GetValue (2), "#M7");
+				Assert.IsFalse (dr.Read (), "#M8");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
+				if (cmd != null)
+					cmd.Dispose ();
+				if (dr != null)
+					dr.Close ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
 		[Test]
 		public void NVarCharParameterTest ()
 		{
-			string query = "select id, type_varchar from string_family where type_varchar = ? and id = 1";
-			IDbConnection conn = ConnectionManager.Singleton.Connection;
+			string insert_data = "insert into string_family (id, type_nvarchar) values (6000, ?)";
+			string select_data = "select type_nvarchar from string_family where type_nvarchar = ? and id = ?";
+			string select_by_id = "select type_nvarchar from string_family where id = ?";
+			string delete_data = "delete from string_family where id = 6000";
+
+			OdbcConnection conn = (OdbcConnection) ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
 			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
+				param.Value = "nv\u092d\u093e\u0930\u0924r";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual ("nv\u092d\u093e\u0930\u0924r", dr.GetValue (0), "#A3");
+				Assert.IsFalse (dr.Read (), "#A4");
+				dr.Close ();
+				cmd.Dispose ();
 
-				OdbcParameter param = cmd.Parameters.Add ("type_varchar", OdbcType.NVarChar);
-				param.Value = "varchar";
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (1, Convert.ToInt32 (reader [0]), "#2 value not matching");
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
+				param.Value = "nv\u092d\u093e\u0930\u0924r ";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual ("nv\u092d\u093e\u0930\u0924r ", dr.GetValue (0), "#B3");
+				Assert.IsFalse (dr.Read (), "#B4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
+				param.Value = string.Empty;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (string.Empty, dr.GetValue (0), "#C3");
+				Assert.IsFalse (dr.Read (), "#C4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
+				Assert.IsFalse (dr.Read (), "#D4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
+				param.Value = "nvarchar ";
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
+				param.Value = "nvarchar ";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual ("nvarchar ", dr.GetValue (0), "#E3");
+				Assert.IsFalse (dr.Read (), "#E4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 6);
+				param.Value = "nv\u0488rchar";
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 6);
+				param.Value = "nv\u0488rchar";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#F1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#F2");
+				Assert.AreEqual ("nv\u0488rch", dr.GetValue (0), "#F3");
+				Assert.IsFalse (dr.Read (), "#F4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 12);
+				param.Value = "nvarch\u0488r ";
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 12);
+				param.Value = "nvarch\u0488r ";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#G2");
+				Assert.AreEqual ("nvarch\u0488r ", dr.GetValue (0), "#G3");
+				Assert.IsFalse (dr.Read (), "#G4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 12);
+				param.Value = string.Empty;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 12);
+				param.Value = string.Empty;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#H1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#H2");
+				Assert.AreEqual (string.Empty, dr.GetValue (0), "#H3");
+				Assert.IsFalse (dr.Read (), "#H4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#I1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#I2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#I3");
+				Assert.IsFalse (dr.Read (), "#I4");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
+				if (cmd != null)
+					cmd.Dispose ();
+				if (dr != null)
+					dr.Close ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
 		[Test]
-
-		public void VarCharParameterTest ()
+		public void VarBinaryParameterTest ()
 		{
-			string query = "select id, type_varchar from string_family where type_varchar = ? and id = 1";
+			string insert_data = "insert into binary_family (id, type_varbinary) values (6000, ?)";
+			string select_data = "select id, type_varbinary from binary_family where type_varbinary = ? and id = ?";
+			string select_by_id = "select id, type_varbinary from binary_family where id = ?";
+			string delete_data = "delete from binary_family where id = 6000";
+
 			IDbConnection conn = ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
 			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+				byte [] bytes = new byte [] { 0x30, 0x31, 0x32,
+					0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+					0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
+					0x37, 0x38, 0x39, 0x30, 0x31, 0x32, 0x33,
+					0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x00,
+					0x44, 0x53};
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
+				param.Value = bytes;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (1, dr.GetValue (0), "#A3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#A4");
+				Assert.AreEqual (bytes, dr.GetValue (1), "#A5");
+				Assert.IsFalse (dr.Read (), "#A6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				bytes = new byte [] { 0x00, 0x39, 0x38, 0x37,
+					0x36, 0x35, 0x00, 0x33, 0x32, 0x31, 0x30,
+					0x31, 0x32, 0x33, 0x34 };
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
+				param.Value = bytes;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (2, dr.GetValue (0), "#B3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#B4");
+				Assert.AreEqual (bytes, dr.GetValue (1), "#B5");
+				Assert.IsFalse (dr.Read (), "#B6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				bytes = new byte [0];
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
+				param.Value = bytes;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (3, dr.GetValue (0), "#C3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#C4");
+				Assert.AreEqual (bytes, dr.GetValue (1), "#C5");
+				Assert.IsFalse (dr.Read (), "#C6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (4, dr.GetValue (0), "#D3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#D4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
+				Assert.IsFalse (dr.Read (), "#D6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				bytes = new byte [0];
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
+				param.Value = bytes;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
+				param.Value = bytes;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#E4");
+				Assert.AreEqual (bytes, dr.GetValue (1), "#E5");
+				Assert.IsFalse (dr.Read (), "#E6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				bytes = new byte [] { 0x05 };
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
+				param.Value = bytes;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
+				param.Value = bytes;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#F1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#F4");
+				Assert.AreEqual (bytes, dr.GetValue (1), "#F5");
+				Assert.IsFalse (dr.Read (), "#F6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				bytes = new byte [] { 0x34, 0x00, 0x32 };
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
+				param.Value = bytes;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
+				param.Value = bytes;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#G4");
+				Assert.AreEqual (bytes, dr.GetValue (1), "#G5");
+				Assert.IsFalse (dr.Read (), "#G6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				bytes = new byte [] { 0x34, 0x00, 0x32, 0x05, 0x07, 0x13 };
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary, 4);
+				param.Value = bytes;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
 
-				OdbcParameter param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar);
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary, 4);
+				param.Value = bytes;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#H1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#H3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#H4");
+				Assert.AreEqual (new byte [] { 0x34, 0x00, 0x32, 0x05 }, dr.GetValue (1), "#H5");
+				Assert.IsFalse (dr.Read (), "#H6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#I1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#I2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#I3");
+				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#I4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#I5");
+				Assert.IsFalse (dr.Read (), "#I6");
+				dr.Close ();
+				cmd.Dispose ();
+			} finally {
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
+			}
+		}
+
+		[Test]
+		public void VarCharParameterTest ()
+		{
+			string insert_data = "insert into string_family (id, type_varchar) values (6000, ?)";
+			string select_data = "select type_varchar from string_family where type_varchar = ? and id = ?";
+			string select_by_id = "select type_varchar from string_family where id = ?";
+			string delete_data = "delete from string_family where id = 6000";
+
+			OdbcConnection conn = (OdbcConnection) ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
+			try {
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar);
 				param.Value = "varchar";
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (1, Convert.ToInt32 (reader [0]), "#2 value not matching");
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual ("varchar", dr.GetValue (0), "#A3");
+				Assert.IsFalse (dr.Read (), "#A4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar);
+				param.Value = "varchar ";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual ("varchar ", dr.GetValue (0), "#B3");
+				Assert.IsFalse (dr.Read (), "#B4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar);
+				param.Value = string.Empty;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (string.Empty, dr.GetValue (0), "#C3");
+				Assert.IsFalse (dr.Read (), "#C4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
+				Assert.IsFalse (dr.Read (), "#D4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar, 30);
+				param.Value = "varchar ";
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar);
+				param.Value = "varchar ";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual ("varchar ", dr.GetValue (0), "#E3");
+				Assert.IsFalse (dr.Read (), "#E4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar, 3);
+				param.Value = "vchar";
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.VarChar, 3);
+				param.Value = "vcharxzer";
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#F1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#F2");
+				Assert.AreEqual ("vch", dr.GetValue (0), "#F3");
+				Assert.IsFalse (dr.Read (), "#F4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar, 3);
+				param.Value = string.Empty;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.VarChar, 3);
+				param.Value = string.Empty;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#G2");
+				Assert.AreEqual (string.Empty, dr.GetValue (0), "#G3");
+				Assert.IsFalse (dr.Read (), "#G4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar, 5);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#H1");
+				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#H2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#H3");
+				Assert.IsFalse (dr.Read (), "#H4");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
+				if (cmd != null)
+					cmd.Dispose ();
+				if (dr != null)
+					dr.Close ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
 		[Test]
 		public void RealParameterTest ()
 		{
-			string query = "select id, type_float from numeric_family where type_float = ? and id = 1";
+			string insert_data = "insert into numeric_family (id, type_float) values (6000, ?)";
+			string select_data = "select id, type_float from numeric_family where type_float = ? and id = ?";
+			string select_by_id = "select id, type_float from numeric_family where id = ?";
+			string delete_data = "delete from numeric_family where id = 6000";
+
 			IDbConnection conn = ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
 			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
 
-				OdbcParameter param = cmd.Parameters.Add ("type_float", OdbcType.Real);
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (1, dr.GetValue (0), "#D3");
+				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#D4");
+				Assert.AreEqual (3.40E+38, dr.GetValue (1), "#D5");
+				Assert.IsFalse (dr.Read (), "#D6");
+				dr.Close ();
+				cmd.Dispose ();
+
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_float", OdbcType.Real);
 				param.Value = 3.40E+38;
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (1, Convert.ToInt32 (reader [0]), "#2 value not matching");
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (1, dr.GetValue (0), "#A2");
+				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#A3");
+				Assert.AreEqual (3.40E+38, dr.GetValue (1), "#A4");
+				Assert.IsFalse (dr.Read (), "#A5");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_float", OdbcType.Real);
+				param.Value = -3.40E+38;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 2;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (2, dr.GetValue (0), "#B2");
+				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#B3");
+				Assert.AreEqual (-3.40E+38, dr.GetValue (1), "#B4");
+				Assert.IsFalse (dr.Read (), "#B5");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_float", OdbcType.Real);
+				param.Value = 0F;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 3;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (3, dr.GetValue (0), "#C2");
+				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#C3");
+				Assert.AreEqual (0F, dr.GetValue (1), "#C4");
+				Assert.IsFalse (dr.Read (), "#C5");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (4, dr.GetValue (0), "#D3");
+				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#D4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
+				Assert.IsFalse (dr.Read (), "#D6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_float", OdbcType.Real);
+				param.Value = 3.40E+38;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#E1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
+				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#E4");
+				Assert.AreEqual (3.40E+38, dr.GetValue (1), "#E5");
+				Assert.IsFalse (dr.Read (), "#E6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_float", OdbcType.Real);
+				param.Value = -3.40E+38;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#F1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
+				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#F4");
+				Assert.AreEqual (-3.40E+38, dr.GetValue (1), "#F5");
+				Assert.IsFalse (dr.Read (), "#F6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_float", OdbcType.Real);
+				param.Value = 0F;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#G1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
+				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#G4");
+				Assert.AreEqual (0F, dr.GetValue (1), "#G5");
+				Assert.IsFalse (dr.Read (), "#G6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_float", OdbcType.Real);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#H1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#H3");
+				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#H4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
+				Assert.IsFalse (dr.Read (), "#H6");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
 		[Test]
 		public void SmallDateTimeParameterTest ()
 		{
-			string query = "select id, type_smalldatetime from datetime_family where type_smalldatetime = ? and id = 1";
+			string insert_data = "insert into datetime_family (id, type_smalldatetime) values (6000, ?)";
+			string select_data = "select id, type_smalldatetime from datetime_family where type_smalldatetime = ? and id = ?";
+			string select_by_id = "select id, type_smalldatetime from datetime_family where id = ?";
+			string delete_data = "delete from datetime_family where id = 6000";
+
 			IDbConnection conn = ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
 			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+				DateTime date = DateTime.Parse ("2037-12-31 23:59:00");
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_smalldatetime", OdbcType.SmallDateTime);
+				param.Value = date;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (1, dr.GetValue (0), "#A3");
+				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#A4");
+				Assert.AreEqual (date, dr.GetValue (1), "#A5");
+				Assert.IsFalse (dr.Read (), "#A6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (4, dr.GetValue (0), "#B3");
+				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#B4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#B5");
+				Assert.IsFalse (dr.Read (), "#B6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				date = new DateTime (1973, 8, 13, 17, 55, 00);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_smalldatetime", OdbcType.SmallDateTime);
+				param.Value = date;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_smalldatetime", OdbcType.SmallDateTime);
+				param.Value = date;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#C3");
+				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#C4");
+				Assert.AreEqual (date, dr.GetValue (1), "#C5");
+				Assert.IsFalse (dr.Read (), "#C6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_smalldatetime", OdbcType.SmallDateTime);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
 
-				OdbcParameter param = cmd.Parameters.Add ("type_smalldatetime", OdbcType.SmallDateTime);
-				param.Value = DateTime.Parse ("2079-06-06 23:59:00");
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (1, Convert.ToInt32 (reader [0]), "#2 value not matching");
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#D3");
+				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#D4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
+				Assert.IsFalse (dr.Read (), "#D6");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
 		[Test]
 		public void DateTimeParameterTest ()
 		{
-			string query = "select id, type_datetime from datetime_family where type_datetime = ? and id = 1";
-			IDbConnection conn = ConnectionManager.Singleton.Connection;
+			string insert_data = "insert into datetime_family (id, type_datetime) values (6000, ?)";
+			string select_data = "select id, type_datetime from datetime_family where type_datetime = ? and id = ?";
+			string select_by_id = "select id, type_datetime from datetime_family where id = ?";
+			string delete_data = "delete from datetime_family where id = 6000";
+
+			OdbcConnection conn = (OdbcConnection) ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
 			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+				DateTime date = DateTime.ParseExact ("9999-12-31 23:59:59.997",
+					"yyyy-MM-dd HH:mm:ss.fff", CultureInfo.InvariantCulture);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_datetime", OdbcType.DateTime);
+				param.Value = date;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (1, dr [0], "#A3");
+				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#A4");
+				if (ConnectionManager.Singleton.Engine.SupportsMicroseconds)
+					Assert.AreEqual (date, dr [1], "#A5");
+				else
+					Assert.AreEqual (new DateTime (9999, 12, 31, 23, 59, 59), dr [1], "#A5");
+				Assert.IsFalse (dr.Read (), "#A6");
+				dr.Close ();
+				cmd.Dispose ();
 
-				OdbcParameter param = cmd.Parameters.Add ("type_datetime", OdbcType.DateTime);
-				param.Value = DateTime.ParseExact ("9999-12-31 23:59:59.997", "yyyy-MM-dd HH:mm:ss.fff", CultureInfo.InvariantCulture);
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (1, Convert.ToInt32 (reader [0]), "#2 value not matching");
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (4, dr.GetValue (0), "#B3");
+				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#B4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#B5");
+				Assert.IsFalse (dr.Read (), "#B6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				date = new DateTime (1973, 8, 13, 17, 54, 33, 953);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_datetime", OdbcType.DateTime);
+				param.Value = date;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_datetime", OdbcType.DateTime);
+				param.Value = date;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#C3");
+				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#C4");
+				if (ConnectionManager.Singleton.Engine.SupportsMicroseconds)
+					Assert.AreEqual (date, dr.GetValue (1), "#C5");
+				else
+					Assert.AreEqual (new DateTime (1973, 8, 13, 17, 54, 33), dr.GetValue (1), "#C5");
+				Assert.IsFalse (dr.Read (), "#C6");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_datetime", OdbcType.DateTime);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (6000, dr.GetValue (0), "#D3");
+				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#D4");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
+				Assert.IsFalse (dr.Read (), "#D6");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
 		[Test]
-		[Ignore ("Not running on ms.net")]
 		public void DateParameterTest ()
 		{
-			string query = "select id, type_datetime from datetime_family where type_datetime = ? and id = 1";
-			IDbConnection conn = ConnectionManager.Singleton.Connection;
+			string insert_data = "insert into datetime_family (id, type_date) values (6000, ?)";
+			string select_data = "select type_date from datetime_family where type_date = ? and id = 1";
+			string select_by_id = "select type_date from datetime_family where id = ?";
+			string delete_data = "delete from datetime_family where id = 6000";
+
+			OdbcConnection conn = (OdbcConnection) ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
 			try {
-				ConnectionManager.Singleton.OpenConnection ();
-				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
-				cmd.CommandText = query;
+				if (!ConnectionManager.Singleton.Engine.SupportsDate)
+					Assert.Ignore ("Date test does not apply to the current driver (" + conn.Driver + ").");
 
-				OdbcParameter param = cmd.Parameters.Add ("type_datetime", OdbcType.Date);
-				param.Value = DateTime.ParseExact ("9999-12-31 23:59:59.997", "yyyy-MM-dd HH:mm:ss.fff", CultureInfo.InvariantCulture);
-				OdbcDataReader reader = cmd.ExecuteReader ();
-				Assert.IsTrue (reader.Read (), "#1 no data to test");
-				Assert.AreEqual (1, Convert.ToInt32 (reader [0]), "#2 value not matching");
+				DateTime date = new DateTime (9999, 12, 31);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_date", OdbcType.DateTime);
+				param.Value = date;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (date, dr.GetValue (0), "#A3");
+				Assert.IsFalse (dr.Read (), "#A4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#B3");
+				Assert.IsFalse (dr.Read (), "#B4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				date = new DateTime (2004, 2, 21, 4, 50, 7);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_date", OdbcType.Date);
+				param.Value = date;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (new DateTime (2004, 2, 21), dr.GetValue (0), "#C3");
+				Assert.IsFalse (dr.Read (), "#C4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_date", OdbcType.Date);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
+				Assert.IsFalse (dr.Read (), "#D4");
+				dr.Close ();
+				cmd.Dispose ();
 			} finally {
-				ConnectionManager.Singleton.CloseConnection ();
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
+			}
+		}
+
+		[Test]
+		public void TimeParameterTest ()
+		{
+			string insert_data = "insert into datetime_family (id, type_time) values (6000, ?)";
+			string select_data = "select type_time from datetime_family where type_time = ? and id = 1";
+			string select_by_id = "select type_time from datetime_family where id = ?";
+			string delete_data = "delete from datetime_family where id = 6000";
+
+			OdbcConnection conn = (OdbcConnection) ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
+			try {
+				if (!ConnectionManager.Singleton.Engine.SupportsTime)
+					Assert.Ignore ("Time test does not apply to the current driver (" + conn.Driver + ").");
+
+				TimeSpan time = ConnectionManager.Singleton.Engine.SupportsMicroseconds ?
+					new TimeSpan (23, 58, 59, 953) : new TimeSpan (23, 58, 59);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_time", OdbcType.Time);
+				param.Value = time;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (typeof (TimeSpan), dr.GetFieldType (0), "#A2");
+				Assert.AreEqual (time, dr.GetValue (0), "#A3");
+				Assert.IsFalse (dr.Read (), "#A4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (typeof (TimeSpan), dr.GetFieldType (0), "#B2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#B3");
+				Assert.IsFalse (dr.Read (), "#B4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				time = new TimeSpan (23, 56, 43);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_time", OdbcType.Time);
+				param.Value = time;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (typeof (TimeSpan), dr.GetFieldType (0), "#C2");
+				Assert.AreEqual (time, dr.GetValue (0), "#C3");
+				Assert.IsFalse (dr.Read (), "#C4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_time", OdbcType.Date);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (typeof (TimeSpan), dr.GetFieldType (0), "#D2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
+				Assert.IsFalse (dr.Read (), "#D4");
+				dr.Close ();
+				cmd.Dispose ();
+			} finally {
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
+			}
+		}
+
+		[Test]
+		public void UniqueIdentifierParameterTest ()
+		{
+			string insert_data = "insert into string_family (id, type_guid) values (6000, ?)";
+			string select_data = "select id, type_guid from string_family where type_guid = ? and id = ?";
+			string select_by_id = "select id, type_guid from string_family where id = ?";
+			string delete_data = "delete from string_family where id = 6000";
+
+			OdbcConnection conn = (OdbcConnection) ConnectionManager.Singleton.Connection;
+			conn.Open ();
+
+			IDataReader dr = null;
+			OdbcCommand cmd = null;
+			OdbcParameter param;
+
+			try {
+				if (!ConnectionManager.Singleton.Engine.SupportsUniqueIdentifier)
+					Assert.Ignore ("UniqueIdentifier test does not apply to the current driver (" + conn.Driver + ").");
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_guid", OdbcType.UniqueIdentifier);
+				param.Value = new Guid ("d222a130-6383-4d36-ac5e-4e6b2591aabf");
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 1;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#A1");
+				Assert.AreEqual (1, dr.GetValue (0), "#A2");
+				Assert.AreEqual (new Guid ("d222a130-6383-4d36-ac5e-4e6b2591aabf"), dr.GetValue (1), "#A3");
+				Assert.IsFalse (dr.Read (), "#A4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 4;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#B1");
+				Assert.AreEqual (4, dr.GetValue (0), "#B2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#B3");
+				Assert.IsFalse (dr.Read (), "#B4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_guid", OdbcType.UniqueIdentifier);
+				param.Value = new Guid ("e222a130-6383-4d36-ac5e-4e6b2591aabe");
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_data;
+				param = cmd.Parameters.Add ("type_guid", OdbcType.UniqueIdentifier);
+				param.Value = new Guid ("e222a130-6383-4d36-ac5e-4e6b2591aabe");
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#C1");
+				Assert.AreEqual (6000, dr.GetValue (0), "#C2");
+				Assert.AreEqual (new Guid ("e222a130-6383-4d36-ac5e-4e6b2591aabe"), dr.GetValue (1), "#C3");
+				Assert.IsFalse (dr.Read (), "#C4");
+				dr.Close ();
+				cmd.Dispose ();
+
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+
+				cmd = (OdbcCommand) conn.CreateCommand ();
+				cmd.CommandText = insert_data;
+				param = cmd.Parameters.Add ("type_guid", OdbcType.UniqueIdentifier);
+				param.Value = DBNull.Value;
+				cmd.ExecuteNonQuery ();
+				cmd.Dispose ();
+
+				cmd = conn.CreateCommand ();
+				cmd.CommandText = select_by_id;
+				param = cmd.Parameters.Add ("id", OdbcType.Int);
+				param.Value = 6000;
+				dr = cmd.ExecuteReader ();
+				Assert.IsTrue (dr.Read (), "#D1");
+				Assert.AreEqual (6000, dr.GetValue (0), "#D2");
+				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D3");
+				Assert.IsFalse (dr.Read (), "#D4");
+				dr.Close ();
+				cmd.Dispose ();
+			} finally {
+				if (dr != null)
+					dr.Close ();
+				if (cmd != null)
+					cmd.Dispose ();
+
+				conn.Close ();
+				conn.Open ();
+				DBHelper.ExecuteNonQuery (conn, delete_data);
+				conn.Close ();
 			}
 		}
 
@@ -482,49 +4261,103 @@ namespace MonoTests.System.Data
 				ConnectionManager.Singleton.CloseConnection ();
 			}
 		}
-		
+
+		[Test]
+		public void ParameterName ()
+		{
+			OdbcParameter p = new OdbcParameter ();
+			p.ParameterName = "foo1";
+			Assert.AreEqual ("foo1", p.ParameterName, "#1");
+			p.ParameterName = null;
+			Assert.AreEqual (string.Empty, p.ParameterName, "#2");
+			p.ParameterName = "foo2";
+			Assert.AreEqual ("foo2", p.ParameterName, "#3");
+			p.ParameterName = string.Empty;
+			Assert.AreEqual (string.Empty, p.ParameterName, "#4");
+		}
+
+		[Test]
+		public void SourceColumn ()
+		{
+			OdbcParameter p = new OdbcParameter ();
+			p.SourceColumn = "foo1";
+			Assert.AreEqual ("foo1", p.SourceColumn, "#1");
+			p.SourceColumn = null;
+			Assert.AreEqual (string.Empty, p.SourceColumn, "#2");
+			p.SourceColumn = "foo2";
+			Assert.AreEqual ("foo2", p.SourceColumn, "#3");
+			p.SourceColumn = string.Empty;
+			Assert.AreEqual (string.Empty, p.SourceColumn, "#4");
+		}
+
 		[Test]
 		public void DefaultValuesTest ()
 		{
-			OdbcParameter p1 = new OdbcParameter();
-			Assert.AreEqual (OdbcType.NVarChar, p1.OdbcType, "#1 parameters without type are NVarChar by default");
-			Assert.AreEqual (String.Empty, p1.ParameterName, "#2 parameters have empty string as name");
-			Assert.AreEqual (false, p1.IsNullable, "#3 IsNullable is set to false by default");
-			Assert.AreEqual (String.Empty, p1.SourceColumn, "#4 SourceColumn is set to empty string by default");
-			Assert.AreEqual (ParameterDirection.Input, p1.Direction, "#5 ParameterDirection is input by default");
-			Assert.AreEqual (null, p1.Value, "#6 Parameter value must be null by default");
-			
-			OdbcParameter p2 = new OdbcParameter(null, 2);
-			Assert.AreEqual (OdbcType.NVarChar, p2.OdbcType, "#7 parameters without type are NVarChar by default");
-			Assert.AreEqual (String.Empty, p2.ParameterName, "#8 parameters have empty string as name");
-			Assert.AreEqual (false, p2.IsNullable, "#9 IsNullable is set to false by default");
-			Assert.AreEqual (String.Empty, p2.SourceColumn, "#10 SourceColumn is set to empty string by default");
-			Assert.AreEqual (ParameterDirection.Input, p2.Direction, "#11 ParameterDirection is input by default");
-			Assert.AreEqual (2, p2.Value, "#12 Parameter value must be 2");
-			
-			OdbcParameter p3 = new OdbcParameter("foo", 2);
-			Assert.AreEqual (OdbcType.NVarChar, p3.OdbcType, "#13 parameters without type are NVarChar by default");
-			Assert.AreEqual ("foo", p3.ParameterName, "#14 parameter must have foo as name");
-			Assert.AreEqual (false, p3.IsNullable, "#15 IsNullable is set to false by default");
-			Assert.AreEqual (String.Empty, p3.SourceColumn, "#16 SourceColumn is set to empty string by default");
-			Assert.AreEqual (ParameterDirection.Input, p3.Direction, "#17 ParameterDirection is input by default");
-			Assert.AreEqual (2, p3.Value, "#18 Parameter value must be 2");
-			
-			OdbcParameter p4 = new OdbcParameter("foo1", OdbcType.Int);
-			Assert.AreEqual (OdbcType.Int, p4.OdbcType, "#19 parameters without type are NVarChar by default");
-			Assert.AreEqual ("foo1", p4.ParameterName, "#20 parameter must have foo1 as name");
-			Assert.AreEqual (false, p4.IsNullable, "#21 IsNullable is set to false by default");
-			Assert.AreEqual (String.Empty, p4.SourceColumn, "#22 SourceColumn is set to empty string by default");
-			Assert.AreEqual (ParameterDirection.Input, p4.Direction, "#23 ParameterDirection is input by default");
-			Assert.AreEqual (null, p4.Value, "#24 Parameter value must be 2");		
-			
-			OdbcParameter p5 = new OdbcParameter("foo2", Convert.ToInt32(2));
-			Assert.AreEqual (OdbcType.NVarChar, p5.OdbcType, "#25 parameters without type are NVarChar by default");
-			Assert.AreEqual ("foo2", p5.ParameterName, "#26 parameter must have foo2 as name");
-			Assert.AreEqual (false, p5.IsNullable, "#27 IsNullable is set to false by default");
-			Assert.AreEqual (String.Empty, p5.SourceColumn, "#28 SourceColumn is set to empty string by default");
-			Assert.AreEqual (ParameterDirection.Input, p5.Direction, "#29 ParameterDirection is input by default");
-			Assert.AreEqual (2, p5.Value, "#30 Parameter value must be 2");	
+			OdbcParameter p;
+
+			p = new OdbcParameter();
+			Assert.AreEqual (DbType.String, p.DbType, "#A:DbType");
+			Assert.AreEqual (ParameterDirection.Input, p.Direction, "#A:Direction");
+			Assert.IsFalse (p.IsNullable, "#A:IsNullable");
+			Assert.AreEqual (OdbcType.NVarChar, p.OdbcType, "#A:OdbcType");
+			Assert.AreEqual (String.Empty, p.ParameterName, "#A:ParameterName");
+			Assert.AreEqual (0, p.Precision, "#A:Precision");
+			Assert.AreEqual (0, p.Scale, "#A:Scale");
+			Assert.AreEqual (0, p.Size, "#A:Size");
+			Assert.AreEqual (String.Empty, p.SourceColumn, "#A:SourceColumn");
+#if NET_2_0
+			Assert.IsFalse (p.SourceColumnNullMapping, "#A:SourceColumnNullMapping");
+#endif
+			Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "#A:SourceVersion");
+			Assert.IsNull (p.Value, "#A:Value");
+
+			p = new OdbcParameter(null, 2);
+			Assert.AreEqual (DbType.String, p.DbType, "#B:DbType");
+			Assert.AreEqual (ParameterDirection.Input, p.Direction, "#B:Direction");
+			Assert.IsFalse (p.IsNullable, "#B:IsNullable");
+			Assert.AreEqual (OdbcType.NVarChar, p.OdbcType, "#B:OdbcType");
+			Assert.AreEqual (String.Empty, p.ParameterName, "#B:ParameterName");
+			Assert.AreEqual (0, p.Precision, "#B:Precision");
+			Assert.AreEqual (0, p.Scale, "#B:Scale");
+			Assert.AreEqual (0, p.Size, "#B:Size");
+			Assert.AreEqual (String.Empty, p.SourceColumn, "#B:SourceColumn");
+#if NET_2_0
+			Assert.IsFalse (p.SourceColumnNullMapping, "#B:SourceColumnNullMapping");
+#endif
+			Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "#B:SourceVersion");
+			Assert.AreEqual (2, p.Value, "#B:Value");
+
+			p = new OdbcParameter("foo", 2);
+			Assert.AreEqual (DbType.String, p.DbType, "#C:DbType");
+			Assert.AreEqual (ParameterDirection.Input, p.Direction, "#C:Direction");
+			Assert.IsFalse (p.IsNullable, "#C:IsNullable");
+			Assert.AreEqual (OdbcType.NVarChar, p.OdbcType, "#C:OdbcType");
+			Assert.AreEqual ("foo", p.ParameterName, "#C:ParameterName");
+			Assert.AreEqual (0, p.Precision, "#C:Precision");
+			Assert.AreEqual (0, p.Scale, "#C:Scale");
+			Assert.AreEqual (0, p.Size, "#C:Size");
+			Assert.AreEqual (String.Empty, p.SourceColumn, "#C:SourceColumn");
+#if NET_2_0
+			Assert.IsFalse (p.SourceColumnNullMapping, "#C:SourceColumnNullMapping");
+#endif
+			Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "#C:SourceVersion");
+			Assert.AreEqual (2, p.Value, "#C:Value");
+
+			p = new OdbcParameter("foo1", OdbcType.Int);
+			Assert.AreEqual (DbType.Int32, p.DbType, "#D:DbType");
+			Assert.AreEqual (ParameterDirection.Input, p.Direction, "#D:Direction");
+			Assert.IsFalse (p.IsNullable, "#D:IsNullable");
+			Assert.AreEqual (OdbcType.Int, p.OdbcType, "#D:OdbcType");
+			Assert.AreEqual ("foo1", p.ParameterName, "#D:ParameterName");
+			Assert.AreEqual (0, p.Precision, "#D:Precision");
+			Assert.AreEqual (0, p.Scale, "#D:Scale");
+			Assert.AreEqual (0, p.Size, "#D:Size");
+			Assert.AreEqual (String.Empty, p.SourceColumn, "#D:SourceColumn");
+#if NET_2_0
+			Assert.IsFalse (p.SourceColumnNullMapping, "#D:SourceColumnNullMapping");
+#endif
+			Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "#D:SourceVersion");
+			Assert.IsNull (p.Value, "#D:Value");
 		}
 	}
 }