* SqlParameterTest.cs: Added .ctor tests. Improved

ParameterType and ResetDbType tests. Added ParameterName,
SourceColumn and Value tests. Partially enable SqlValue
test.

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

2 files changed, 391 insertions, 106 deletions

diff --git a/mcs/class/System.Data/Test/System.Data.SqlClient/ChangeLog b/mcs/class/System.Data/Test/System.Data.SqlClient/ChangeLog
index a1892e72039..bc889a1a415 100644
--- a/mcs/class/System.Data/Test/System.Data.SqlClient/ChangeLog
+++ b/mcs/class/System.Data/Test/System.Data.SqlClient/ChangeLog
@@ -1,5 +1,12 @@
 2009-01-03  Gert Driesen  <drieseng@users.sourceforge.net>
 
+	* SqlParameterTest.cs: Added .ctor tests. Improved 
+	ParameterType and ResetDbType tests. Added ParameterName,
+	SourceColumn and Value tests. Partially enable SqlValue
+	test.
+
+2009-01-03  Gert Driesen  <drieseng@users.sourceforge.net>
+
 	* SqlCommandBuilderTest.cs: Added tests for CatalogLocation,
 	CatalogSeparator, ConflictOption, QuoteIdentifier, QuotePrefix,
 	QuoteSuffix  and SchemaSeparator.
diff --git a/mcs/class/System.Data/Test/System.Data.SqlClient/SqlParameterTest.cs b/mcs/class/System.Data/Test/System.Data.SqlClient/SqlParameterTest.cs
index 5cbaebe2d19..9e737fa7745 100644
--- a/mcs/class/System.Data/Test/System.Data.SqlClient/SqlParameterTest.cs
+++ b/mcs/class/System.Data/Test/System.Data.SqlClient/SqlParameterTest.cs
@@ -42,6 +42,134 @@ namespace MonoTests.System.Data.SqlClient
 	[TestFixture]
 	public class SqlParameterTest
 	{
+		[Test]
+		public void Constructor1 ()
+		{
+			SqlParameter p = new SqlParameter ();
+			Assert.AreEqual (DbType.String, p.DbType, "DbType");
+			Assert.AreEqual (ParameterDirection.Input, p.Direction, "Direction");
+			Assert.IsFalse (p.IsNullable, "IsNullable");
+#if NET_2_0
+			Assert.AreEqual (0, p.LocaleId, "LocaleId");
+#endif
+			Assert.AreEqual (string.Empty, p.ParameterName, "ParameterName");
+			Assert.AreEqual (0, p.Precision, "Precision");
+			Assert.AreEqual (0, p.Scale, "Scale");
+			Assert.AreEqual (0, p.Size, "Size");
+			Assert.AreEqual (string.Empty, p.SourceColumn, "SourceColumn");
+#if NET_2_0
+			Assert.IsFalse (p.SourceColumnNullMapping, "SourceColumnNullMapping");
+#endif
+			Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "SourceVersion");
+			Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "SqlDbType");
+#if NET_2_0
+			Assert.IsNull (p.SqlValue, "SqlValue");
+#endif
+			Assert.IsNull (p.Value, "Value");
+#if NET_2_0
+			Assert.AreEqual (string.Empty, p.XmlSchemaCollectionDatabase, "XmlSchemaCollectionDatabase");
+			Assert.AreEqual (string.Empty, p.XmlSchemaCollectionName, "XmlSchemaCollectionName");
+			Assert.AreEqual (string.Empty, p.XmlSchemaCollectionOwningSchema, "XmlSchemaCollectionOwningSchema");
+#endif
+		}
+
+		[Test]
+		public void Constructor2_Value_DateTime ()
+		{
+			DateTime value = new DateTime (2004, 8, 24);
+
+			SqlParameter p = new SqlParameter ("address", value);
+			Assert.AreEqual (DbType.DateTime, p.DbType, "B:DbType");
+			Assert.AreEqual (ParameterDirection.Input, p.Direction, "B:Direction");
+			Assert.IsFalse (p.IsNullable, "B:IsNullable");
+#if NET_2_0
+			Assert.AreEqual (0, p.LocaleId, "B:LocaleId");
+#endif
+			Assert.AreEqual ("address", 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 (SqlDbType.DateTime, p.SqlDbType, "B:SqlDbType");
+#if NET_2_0
+			// FIXME
+			//Assert.AreEqual (new SqlDateTime (value), p.SqlValue, "B:SqlValue");
+#endif
+			Assert.AreEqual (value, p.Value, "B:Value");
+#if NET_2_0
+			Assert.AreEqual (string.Empty, p.XmlSchemaCollectionDatabase, "B:XmlSchemaCollectionDatabase");
+			Assert.AreEqual (string.Empty, p.XmlSchemaCollectionName, "B:XmlSchemaCollectionName");
+			Assert.AreEqual (string.Empty, p.XmlSchemaCollectionOwningSchema, "B:XmlSchemaCollectionOwningSchema");
+#endif
+		}
+
+		[Test]
+		public void Constructor2_Value_DBNull ()
+		{
+			SqlParameter p = new SqlParameter ("address", DBNull.Value);
+			Assert.AreEqual (DbType.String, p.DbType, "B:DbType");
+			Assert.AreEqual (ParameterDirection.Input, p.Direction, "B:Direction");
+			Assert.IsFalse (p.IsNullable, "B:IsNullable");
+#if NET_2_0
+			Assert.AreEqual (0, p.LocaleId, "B:LocaleId");
+#endif
+			Assert.AreEqual ("address", 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 (SqlDbType.NVarChar, p.SqlDbType, "B:SqlDbType");
+#if NET_2_0
+			// FIXME
+			//Assert.AreEqual (SqlString.Null, p.SqlValue, "B:SqlValue");
+#endif
+			Assert.AreEqual (DBNull.Value, p.Value, "B:Value");
+#if NET_2_0
+			Assert.AreEqual (string.Empty, p.XmlSchemaCollectionDatabase, "B:XmlSchemaCollectionDatabase");
+			Assert.AreEqual (string.Empty, p.XmlSchemaCollectionName, "B:XmlSchemaCollectionName");
+			Assert.AreEqual (string.Empty, p.XmlSchemaCollectionOwningSchema, "B:XmlSchemaCollectionOwningSchema");
+#endif
+		}
+
+		[Test]
+		public void Constructor2_Value_Null ()
+		{
+			SqlParameter p = new SqlParameter ("address", (Object) null);
+			Assert.AreEqual (DbType.String, p.DbType, "A:DbType");
+			Assert.AreEqual (ParameterDirection.Input, p.Direction, "A:Direction");
+			Assert.IsFalse (p.IsNullable, "A:IsNullable");
+#if NET_2_0
+			Assert.AreEqual (0, p.LocaleId, "A:LocaleId");
+#endif
+			Assert.AreEqual ("address", 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.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "A:SqlDbType");
+#if NET_2_0
+			Assert.IsNull (p.SqlValue, "A:SqlValue");
+#endif
+			Assert.IsNull (p.Value, "A:Value");
+#if NET_2_0
+			Assert.AreEqual (string.Empty, p.XmlSchemaCollectionDatabase, "A:XmlSchemaCollectionDatabase");
+			Assert.AreEqual (string.Empty, p.XmlSchemaCollectionName, "A:XmlSchemaCollectionName");
+			Assert.AreEqual (string.Empty, p.XmlSchemaCollectionOwningSchema, "A:XmlSchemaCollectionOwningSchema");
+#endif
+		}
+
 #if NET_2_0
 		[Test] // .ctor (String, SqlDbType, Int32, ParameterDirection, Byte, Byte, String, DataRowVersion, Boolean, Object, String, String, String)
 		public void Constructor7 ()
@@ -481,66 +609,76 @@ namespace MonoTests.System.Data.SqlClient
 		}
 
 		[Test]
-#if ONLY_1_1
-		[Category ("NotWorking")]
-#endif
 		public void ParameterType ()
 		{
+			SqlParameter p;
+
 			// If Type is not set, then type is inferred from the value
 			// assigned. The Type should be inferred everytime Value is assigned
 			// If value is null or DBNull, then the current Type should be reset to NVarChar.
-			SqlParameter param = new SqlParameter ();
-			Assert.AreEqual (DbType.String, param.DbType, "#A1");
-			Assert.AreEqual (SqlDbType.NVarChar, param.SqlDbType, "#A2");
-			param.Value = DBNull.Value;
-			Assert.AreEqual (DbType.String, param.DbType, "#A3");
-			Assert.AreEqual (SqlDbType.NVarChar, param.SqlDbType, "#A4");
-			param.Value = 1;
-			Assert.AreEqual (DbType.Int32, param.DbType, "#A5");
-			Assert.AreEqual (SqlDbType.Int, param.SqlDbType, "#A6");
-			param.Value = DBNull.Value;
+			p = new SqlParameter ();
+			Assert.AreEqual (DbType.String, p.DbType, "#A1");
+			Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#A2");
+			p.Value = DBNull.Value;
+			Assert.AreEqual (DbType.String, p.DbType, "#B1");
+			Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#B2");
+			p.Value = 1;
+			Assert.AreEqual (DbType.Int32, p.DbType, "#C1");
+			Assert.AreEqual (SqlDbType.Int, p.SqlDbType, "#C2");
+			p.Value = DBNull.Value;
 #if NET_2_0
-			Assert.AreEqual (DbType.String, param.DbType, "#A7");
-			Assert.AreEqual (SqlDbType.NVarChar, param.SqlDbType, "#A8");
+			Assert.AreEqual (DbType.String, p.DbType, "#D1");
+			Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#D2");
 #else
-			Assert.AreEqual (DbType.Int32, param.DbType, "#A7");
-			Assert.AreEqual (SqlDbType.Int, param.SqlDbType, "#A8");
+			Assert.AreEqual (DbType.Int32, p.DbType, "#D1");
+			Assert.AreEqual (SqlDbType.Int, p.SqlDbType, "#D2");
 #endif
-			param.Value = null;
+			p.Value = new byte [] { 0x0a };
+			Assert.AreEqual (DbType.Binary, p.DbType, "#E1");
+			Assert.AreEqual (SqlDbType.VarBinary, p.SqlDbType, "#E2");
+			p.Value = null;
 #if NET_2_0
-			Assert.AreEqual (DbType.String, param.DbType, "#A9");
-			Assert.AreEqual (SqlDbType.NVarChar, param.SqlDbType, "#A10");
+			Assert.AreEqual (DbType.String, p.DbType, "#F1");
+			Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#F2");
 #else
-			Assert.AreEqual (DbType.Int32, param.DbType, "#A9");
-			Assert.AreEqual (SqlDbType.Int, param.SqlDbType, "#A10");
+			Assert.AreEqual (DbType.Binary, p.DbType, "#F1");
+			Assert.AreEqual (SqlDbType.VarBinary, p.SqlDbType, "#F2");
 #endif
-			param.Value = DateTime.Now;
-			Assert.AreEqual (DbType.DateTime, param.DbType, "#A11");
-			Assert.AreEqual (SqlDbType.DateTime, param.SqlDbType, "#A12");
-			param.Value = null;
+			p.Value = DateTime.Now;
+			Assert.AreEqual (DbType.DateTime, p.DbType, "#G1");
+			Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#G2");
+			p.Value = null;
 #if NET_2_0
-			Assert.AreEqual (DbType.String, param.DbType, "#A13");
-			Assert.AreEqual (SqlDbType.NVarChar, param.SqlDbType, "#A14");
+			Assert.AreEqual (DbType.String, p.DbType, "#H1");
+			Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#H2");
 #else
-			Assert.AreEqual (DbType.DateTime, param.DbType, "#A13");
-			Assert.AreEqual (SqlDbType.DateTime, param.SqlDbType, "#A14");
+			Assert.AreEqual (DbType.DateTime, p.DbType, "#H1");
+			Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#H2");
 #endif
 
 			// If DbType is set, then the SqlDbType should not be
 			// inferred from the value assigned.
-			SqlParameter param1 = new SqlParameter ();
-			param1.DbType = DbType.String;
-			Assert.AreEqual (SqlDbType.NVarChar, param1.SqlDbType, "#B1");
-			param1.Value = 1;
-			Assert.AreEqual (SqlDbType.NVarChar, param1.SqlDbType, "#B2");
+			p = new SqlParameter ();
+			p.DbType = DbType.DateTime;
+			Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#I1");
+			p.Value = 1;
+			Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#I2");
+			p.Value = null;
+			Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#I3");
+			p.Value = DBNull.Value;
+			Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#I4");
 
 			// If SqlDbType is set, then the DbType should not be
 			// inferred from the value assigned.
-			SqlParameter param2 = new SqlParameter ();
-			param2.SqlDbType = SqlDbType.NVarChar;
-			Assert.AreEqual (SqlDbType.NVarChar, param2.SqlDbType, "#C1");
-			param2.Value = 1;
-			Assert.AreEqual (SqlDbType.NVarChar, param2.SqlDbType, "#C2");
+			p = new SqlParameter ();
+			p.SqlDbType = SqlDbType.VarBinary;
+			Assert.AreEqual (SqlDbType.VarBinary, p.SqlDbType, "#J1");
+			p.Value = 1;
+			Assert.AreEqual (SqlDbType.VarBinary, p.SqlDbType, "#J2");
+			p.Value = null;
+			Assert.AreEqual (SqlDbType.VarBinary, p.SqlDbType, "#J3");
+			p.Value = DBNull.Value;
+			Assert.AreEqual (SqlDbType.VarBinary, p.SqlDbType, "#J4");
 		}
 
 		[Test]
@@ -562,45 +700,93 @@ namespace MonoTests.System.Data.SqlClient
 			Assert.AreEqual (DbType.Boolean, param.DbType, "#B2");
 		}
 
+		[Test]
+		public void ParameterName ()
+		{
+			SqlParameter p = new SqlParameter ();
+			p.ParameterName = "name";
+			Assert.AreEqual ("name", p.ParameterName, "#A:ParameterName");
+			Assert.AreEqual (string.Empty, p.SourceColumn, "#A:SourceColumn");
+
+			p.ParameterName = null;
+			Assert.AreEqual (string.Empty, p.ParameterName, "#B:ParameterName");
+			Assert.AreEqual (string.Empty, p.SourceColumn, "#B:SourceColumn");
+
+			p.ParameterName = " ";
+			Assert.AreEqual (" ", p.ParameterName, "#C:ParameterName");
+			Assert.AreEqual (string.Empty, p.SourceColumn, "#C:SourceColumn");
+
+			p.ParameterName = " name ";
+			Assert.AreEqual (" name ", p.ParameterName, "#D:ParameterName");
+			Assert.AreEqual (string.Empty, p.SourceColumn, "#D:SourceColumn");
+
+			p.ParameterName = string.Empty;
+			Assert.AreEqual (string.Empty, p.ParameterName, "#E:ParameterName");
+			Assert.AreEqual (string.Empty, p.SourceColumn, "#E:SourceColumn");
+		}
+
 #if NET_2_0
 		[Test]
 		public void ResetDbType ()
 		{
-			//Parameter with an assigned value but no DbType specified
-			SqlParameter p1 = new SqlParameter ("foo", 42);
-			Assert.AreEqual (42, p1.Value, "#1");
-			Assert.AreEqual (DbType.Int32, p1.DbType, "#2");
-			Assert.AreEqual (SqlDbType.Int, p1.SqlDbType, "#3");
-
-			p1.ResetDbType ();
-			Assert.AreEqual (DbType.Int32, p1.DbType, "#4 The parameter with value 42 must have DbType as Int32");
-			Assert.AreEqual (SqlDbType.Int, p1.SqlDbType, "#5 The parameter with value 42 must have SqlDbType as Int32");
+			SqlParameter p;
 
-			p1.DbType = DbType.DateTime; //assigning a DbType
-			Assert.AreEqual (DbType.DateTime, p1.DbType, "#6");
-			Assert.AreEqual (SqlDbType.DateTime, p1.SqlDbType, "#7");
-			p1.ResetDbType (); //Resetting DbType
-			Assert.AreEqual (DbType.Int32, p1.DbType, "#8 Resetting DbType must infer the type from the value");
-			Assert.AreEqual (SqlDbType.Int, p1.SqlDbType, "#9 Resetting DbType must infer the type from the value");
+			//Parameter with an assigned value but no DbType specified
+			p = new SqlParameter ("foo", 42);
+			p.ResetDbType ();
+			Assert.AreEqual (DbType.Int32, p.DbType, "#A:DbType");
+			Assert.AreEqual (SqlDbType.Int, p.SqlDbType, "#A:SqlDbType");
+			Assert.AreEqual (42, p.Value, "#A:Value");
+
+			p.DbType = DbType.DateTime; //assigning a DbType
+			Assert.AreEqual (DbType.DateTime, p.DbType, "#B:DbType1");
+			Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#B:SqlDbType1");
+			p.ResetDbType ();
+			Assert.AreEqual (DbType.Int32, p.DbType, "#B:DbType2");
+			Assert.AreEqual (SqlDbType.Int, p.SqlDbType, "#B:SqlDbtype2");
 
 			//Parameter with an assigned SqlDbType but no specified value
-			SqlParameter p2 = new SqlParameter ("foo", SqlDbType.Int);
-			Assert.AreEqual (null, p2.Value, "#10");
-			Assert.AreEqual (DbType.Int32, p2.DbType, "#11");
-			Assert.AreEqual (SqlDbType.Int, p2.SqlDbType, "#12");
-
-			//Although a SqlDbType is specified, calling ResetDbType resets 
-			//the SqlDbType and DbType properties to default values
-			p2.ResetDbType (); 
-			Assert.AreEqual (DbType.String, p2.DbType, "#13 Resetting DbType must infer the type from the value");
-			Assert.AreEqual (SqlDbType.NVarChar, p2.SqlDbType, "#14 Resetting DbType must infer the type from the value");
-
-			p2.DbType = DbType.DateTime; //assigning a SqlDbType
-			Assert.AreEqual (DbType.DateTime, p2.DbType, "#15");
-			Assert.AreEqual (SqlDbType.DateTime, p2.SqlDbType, "#16");
-			p2.ResetDbType (); //Resetting DbType
-			Assert.AreEqual (DbType.String, p2.DbType, "#17 Resetting DbType must infer the type from the value");
-			Assert.AreEqual (SqlDbType.NVarChar, p2.SqlDbType, "#18 Resetting DbType must infer the type from the value");
+			p = new SqlParameter ("foo", SqlDbType.Int);
+			p.ResetDbType ();
+			Assert.AreEqual (DbType.String, p.DbType, "#C:DbType");
+			Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#C:SqlDbType");
+
+			p.DbType = DbType.DateTime; //assigning a SqlDbType
+			Assert.AreEqual (DbType.DateTime, p.DbType, "#D:DbType1");
+			Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#D:SqlDbType1");
+			p.ResetDbType ();
+			Assert.AreEqual (DbType.String, p.DbType, "#D:DbType2");
+			Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#D:SqlDbType2");
+
+			p = new SqlParameter ();
+			p.Value = DateTime.MaxValue;
+			Assert.AreEqual (DbType.DateTime, p.DbType, "#E:DbType1");
+			Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#E:SqlDbType1");
+			p.Value = null;
+			p.ResetDbType ();
+			Assert.AreEqual (DbType.String, p.DbType, "#E:DbType2");
+			Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#E:SqlDbType2");
+
+			p = new SqlParameter ("foo", SqlDbType.VarChar);
+			p.Value = DateTime.MaxValue;
+			p.ResetDbType ();
+			Assert.AreEqual (DbType.DateTime, p.DbType, "#F:DbType");
+			Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#F:SqlDbType");
+			Assert.AreEqual (DateTime.MaxValue, p.Value, "#F:Value");
+
+			p = new SqlParameter ("foo", SqlDbType.VarChar);
+			p.Value = DBNull.Value;
+			p.ResetDbType ();
+			Assert.AreEqual (DbType.String, p.DbType, "#G:DbType");
+			Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#G:SqlDbType");
+			Assert.AreEqual (DBNull.Value, p.Value, "#G:Value");
+
+			p = new SqlParameter ("foo", SqlDbType.VarChar);
+			p.Value = null;
+			p.ResetDbType ();
+			Assert.AreEqual (DbType.String, p.DbType, "#G:DbType");
+			Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#G:SqlDbType");
+			Assert.IsNull (p.Value, "#G:Value");
 		}
 
 		[Test]
@@ -642,54 +828,89 @@ namespace MonoTests.System.Data.SqlClient
 			Assert.AreEqual (DbType.String, p2.DbType, "#17 Resetting SqlDbType must infer the type from the value");
 			Assert.AreEqual (SqlDbType.NVarChar, p2.SqlDbType, "#18 Resetting SqlDbType must infer the type from the value");
 		}
+#endif
 
 		[Test]
+		public void SourceColumn ()
+		{
+			SqlParameter p = new SqlParameter ();
+			p.SourceColumn = "name";
+			Assert.AreEqual (string.Empty, p.ParameterName, "#A:ParameterName");
+			Assert.AreEqual ("name", p.SourceColumn, "#A:SourceColumn");
+
+			p.SourceColumn = null;
+			Assert.AreEqual (string.Empty, p.ParameterName, "#B:ParameterName");
+			Assert.AreEqual (string.Empty, p.SourceColumn, "#B:SourceColumn");
+
+			p.SourceColumn = " ";
+			Assert.AreEqual (string.Empty, p.ParameterName, "#C:ParameterName");
+			Assert.AreEqual (" ", p.SourceColumn, "#C:SourceColumn");
+
+			p.SourceColumn = " name ";
+			Assert.AreEqual (string.Empty, p.ParameterName, "#D:ParameterName");
+			Assert.AreEqual (" name ", p.SourceColumn, "#D:SourceColumn");
+
+			p.SourceColumn = string.Empty;
+			Assert.AreEqual (string.Empty, p.ParameterName, "#E:ParameterName");
+			Assert.AreEqual (string.Empty, p.SourceColumn, "#E:SourceColumn");
+		}
+
+#if NET_2_0
+		[Test]
 		public void SourceColumnNullMapping ()
 		{
-			SqlParameter p1 = new SqlParameter ();
-			Assert.IsFalse (p1.SourceColumnNullMapping, "#1");
-			p1.SourceColumnNullMapping = true;
-			Assert.IsTrue (p1.SourceColumnNullMapping, "#2");
-			p1.SourceColumnNullMapping = false;
-			Assert.IsFalse (p1.SourceColumnNullMapping, "#3");
+			SqlParameter p = new SqlParameter ();
+			Assert.IsFalse (p.SourceColumnNullMapping, "#1");
+			p.SourceColumnNullMapping = true;
+			Assert.IsTrue (p.SourceColumnNullMapping, "#2");
+			p.SourceColumnNullMapping = false;
+			Assert.IsFalse (p.SourceColumnNullMapping, "#3");
 		}
 #endif
 
 		[Test]
-#if ONLY_1_1
-		[Category ("NotWorking")]
-#endif
 		public void SqlDbTypeTest ()
 		{
-			SqlParameter p1 = new SqlParameter ();
-			Assert.AreEqual (null, p1.Value, "#1");
-			Assert.AreEqual (SqlDbType.NVarChar, p1.SqlDbType, "#2");
-			Assert.AreEqual (DbType.String, p1.DbType, "#3");
-			
-			SqlParameter p2 = new SqlParameter ("#4 p2Name", (Object)null);
-			Assert.AreEqual (null, p2.Value, "#5");
-			Assert.AreEqual (SqlDbType.NVarChar, p2.SqlDbType, "#6");
-			Assert.AreEqual (DbType.String, p2.DbType, "#7");
-			
-			p2.Value = Convert.ToInt32(42);
-			Assert.AreEqual (42, p2.Value, "#8");
-			Assert.AreEqual (SqlDbType.Int, p2.SqlDbType, "#9");
-			Assert.AreEqual (DbType.Int32, p2.DbType, "#10");
+			SqlParameter p = new SqlParameter ("zipcode", 3510);
+			p.SqlDbType = SqlDbType.DateTime;
+			Assert.AreEqual (DbType.DateTime, p.DbType, "#A:DbType");
+			Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#A:SqlDbType");
+			Assert.AreEqual (3510, p.Value, "#A:Value");
+			p.SqlDbType = SqlDbType.VarChar;
+			Assert.AreEqual (DbType.AnsiString, p.DbType, "#B:DbType");
+			Assert.AreEqual (SqlDbType.VarChar, p.SqlDbType, "#B:SqlDbType");
+			Assert.AreEqual (3510, p.Value, "#B:Value");
+		}
 
-			p2.Value = DBNull.Value;
-			Assert.AreEqual (DBNull.Value, p2.Value, "#11");
+		[Test]
+		public void SqlDbTypeTest_Value_Invalid ()
+		{
+			SqlParameter p = new SqlParameter ("zipcode", 3510);
+			try {
+				p.SqlDbType = (SqlDbType) 666;
+				Assert.Fail ("#1");
+			} catch (ArgumentOutOfRangeException ex) {
 #if NET_2_0
-			Assert.AreEqual (SqlDbType.NVarChar, p2.SqlDbType, "#12");
-			Assert.AreEqual (DbType.String, p2.DbType, "#13");
+				// The SqlDbType enumeration value, 666, is
+				// invalid
+				Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
+				Assert.IsNull (ex.InnerException, "#3");
+				Assert.IsNotNull (ex.Message, "#4");
+				Assert.IsTrue (ex.Message.IndexOf ("666") != -1, "#5:" + ex.Message);
+				Assert.AreEqual ("SqlDbType", ex.ParamName, "#6");
 #else
-			Assert.AreEqual (SqlDbType.Int, p2.SqlDbType, "#12");
-			Assert.AreEqual (DbType.Int32, p2.DbType, "#13");
+				// Specified argument was out of the range of
+				// valid values
+				Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
+				Assert.IsNull (ex.InnerException, "#3");
+				Assert.IsNotNull (ex.Message, "#4");
+				Assert.IsNotNull (ex.ParamName, "#5");
 #endif
+			}
 		}
 
 #if NET_2_0
 		[Test]
-		[Category ("NotWorking")]
 		public void SqlValue ()
 		{
 			SqlParameter parameter = new SqlParameter ();
@@ -698,19 +919,76 @@ namespace MonoTests.System.Data.SqlClient
 			parameter.SqlValue = "Char";
 			Assert.AreEqual (SqlDbType.NVarChar, parameter.SqlDbType, "#B:SqlDbType");
 			Assert.IsNotNull (parameter.SqlValue, "#B:SqlValue1");
-			Assert.AreEqual (typeof (SqlString), parameter.SqlValue.GetType (), "#B:SqlValue2");
-			Assert.AreEqual ("Char", ((SqlString) parameter.SqlValue).Value, "#B:SqlValue3");
+			// FIXME
+			//Assert.AreEqual (typeof (SqlString), parameter.SqlValue.GetType (), "#B:SqlValue2");
+			//Assert.AreEqual ("Char", ((SqlString) parameter.SqlValue).Value, "#B:SqlValue3");
 			Assert.AreEqual ("Char", parameter.Value, "#B:Value");
 
 			parameter.SqlValue = 10;
 			Assert.AreEqual (SqlDbType.Int, parameter.SqlDbType, "#C:SqlDbType");
 			Assert.IsNotNull (parameter.SqlValue, "#C:SqlValue1");
-			Assert.AreEqual (typeof (SqlInt32), parameter.SqlValue.GetType (), "#C:SqlValue2");
-			Assert.AreEqual (10, ((SqlInt32) parameter.SqlValue).Value, "#C:SqlValue3");
+			// FIXME
+			//Assert.AreEqual (typeof (SqlInt32), parameter.SqlValue.GetType (), "#C:SqlValue2");
+			//Assert.AreEqual (10, ((SqlInt32) parameter.SqlValue).Value, "#C:SqlValue3");
 			Assert.AreEqual (10, parameter.Value, "#C:Value");
 		}
+#endif
 
 		[Test]
+		public void Value ()
+		{
+			SqlParameter p;
+
+			p = new SqlParameter ("name", (Object) null);
+			p.Value = 42;
+			Assert.AreEqual (DbType.Int32, p.DbType, "#A:DbType");
+			Assert.AreEqual (SqlDbType.Int, p.SqlDbType, "#A:SqlDbType");
+			Assert.AreEqual (42, p.Value, "#A:Value");
+
+			p.Value = DBNull.Value;
+#if NET_2_0
+			Assert.AreEqual (DbType.String, p.DbType, "#B:DbType");
+			Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#B:SqlDbType");
+#else
+			Assert.AreEqual (DbType.Int32, p.DbType, "#B:DbType");
+			Assert.AreEqual (SqlDbType.Int, p.SqlDbType, "#B:SqlDbType");
+#endif
+			Assert.AreEqual (DBNull.Value, p.Value, "#B:Value");
+
+			p.Value = DateTime.MaxValue;
+			Assert.AreEqual (DbType.DateTime, p.DbType, "#C:DbType");
+			Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#C:SqlDbType");
+			Assert.AreEqual (DateTime.MaxValue, p.Value, "#C:Value");
+
+			p.Value = null;
+#if NET_2_0
+			Assert.AreEqual (DbType.String, p.DbType, "#D:DbType");
+			Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#D:SqlDbType");
+#else
+			Assert.AreEqual (DbType.DateTime, p.DbType, "#D:DbType");
+			Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#D:SqlDbType");
+#endif
+			Assert.IsNull (p.Value, "#D:Value");
+
+			p = new SqlParameter ("zipcode", SqlDbType.Int);
+			p.Value = DateTime.MaxValue;
+			Assert.AreEqual (DbType.Int32, p.DbType, "#E:DbType");
+			Assert.AreEqual (SqlDbType.Int, p.SqlDbType, "#E:SqlDbType");
+			Assert.AreEqual (DateTime.MaxValue, p.Value, "#E:Value");
+
+			p.Value = null;
+			Assert.AreEqual (DbType.Int32, p.DbType, "#F:DbType");
+			Assert.AreEqual (SqlDbType.Int, p.SqlDbType, "#F:SqlDbType");
+			Assert.IsNull (p.Value, "#F:Value");
+
+			p.Value = DBNull.Value;
+			Assert.AreEqual (DbType.Int32, p.DbType, "#G:DbType");
+			Assert.AreEqual (SqlDbType.Int, p.SqlDbType, "#G:SqlDbType");
+			Assert.AreEqual (DBNull.Value, p.Value, "#G:Value");
+		}
+
+#if NET_2_0
+		[Test]
 		public void XmlSchemaTest ()
 		{
 			SqlParameter p1 = new SqlParameter ();