mcs/class/System.Data/Test/System.Data.SqlClient/SqlParameterTest.cs

   1 //
   2 // SqlParameterTest.cs - NUnit Test Cases for testing the
   3 //                          SqlParameter class
   4 // Author:
   5 //      Senganal T (tsenganal@novell.com)
   6 //      Amit Biswas (amit@amitbiswas.com)
   7 //      Gert Driesen (drieseng@users.sourceforge.net)
   8 //
   9 // Copyright (c) 2004 Novell Inc., and the individuals listed
  10 // on the ChangeLog entries.
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 using System;
  33 using System.Data;
  34 using System.Data.Common;
  35 using System.Data.SqlClient;
  36 using System.Data.SqlTypes;
  37 using System.IO;
  38 using System.Xml;
  39
  40 using NUnit.Framework;
  41
  42 namespace MonoTests.System.Data.SqlClient
  43 {
  44         [TestFixture]
  45         public class SqlParameterTest
  46         {
  47                 [Test]
  48 #if FEATURE_NO_BSD_SOCKETS
  49                 [ExpectedException (typeof (PlatformNotSupportedException))]
  50 #endif
  51                 public void Constructor1 ()
  52                 {
  53                         SqlParameter p = new SqlParameter ();
  54                         Assert.AreEqual (DbType.String, p.DbType, "DbType");
  55                         Assert.AreEqual (ParameterDirection.Input, p.Direction, "Direction");
  56                         Assert.IsFalse (p.IsNullable, "IsNullable");
  57                         Assert.AreEqual (0, p.LocaleId, "LocaleId");
  58                         Assert.AreEqual (string.Empty, p.ParameterName, "ParameterName");
  59                         Assert.AreEqual (0, p.Precision, "Precision");
  60                         Assert.AreEqual (0, p.Scale, "Scale");
  61                         Assert.AreEqual (0, p.Size, "Size");
  62                         Assert.AreEqual (string.Empty, p.SourceColumn, "SourceColumn");
  63                         Assert.IsFalse (p.SourceColumnNullMapping, "SourceColumnNullMapping");
  64                         Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "SourceVersion");
  65                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "SqlDbType");
  66                         Assert.IsNull (p.SqlValue, "SqlValue");
  67                         Assert.IsNull (p.Value, "Value");
  68                         Assert.AreEqual (string.Empty, p.XmlSchemaCollectionDatabase, "XmlSchemaCollectionDatabase");
  69                         Assert.AreEqual (string.Empty, p.XmlSchemaCollectionName, "XmlSchemaCollectionName");
  70                         Assert.AreEqual (string.Empty, p.XmlSchemaCollectionOwningSchema, "XmlSchemaCollectionOwningSchema");
  71                 }
  72
  73                 [Test]
  74 #if FEATURE_NO_BSD_SOCKETS
  75                 [ExpectedException (typeof (PlatformNotSupportedException))]
  76 #endif
  77                 public void Constructor2_Value_DateTime ()
  78                 {
  79                         DateTime value = new DateTime (2004, 8, 24);
  80
  81                         SqlParameter p = new SqlParameter ("address", value);
  82                         Assert.AreEqual (DbType.DateTime, p.DbType, "B:DbType");
  83                         Assert.AreEqual (ParameterDirection.Input, p.Direction, "B:Direction");
  84                         Assert.IsFalse (p.IsNullable, "B:IsNullable");
  85                         Assert.AreEqual (0, p.LocaleId, "B:LocaleId");
  86                         Assert.AreEqual ("address", p.ParameterName, "B:ParameterName");
  87                         Assert.AreEqual (0, p.Precision, "B:Precision");
  88                         Assert.AreEqual (0, p.Scale, "B:Scale");
  89                         //Assert.AreEqual (0, p.Size, "B:Size");
  90                         Assert.AreEqual (string.Empty, p.SourceColumn, "B:SourceColumn");
  91                         Assert.IsFalse (p.SourceColumnNullMapping, "B:SourceColumnNullMapping");
  92                         Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "B:SourceVersion");
  93                         Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "B:SqlDbType");
  94                         // FIXME
  95                         //Assert.AreEqual (new SqlDateTime (value), p.SqlValue, "B:SqlValue");
  96                         Assert.AreEqual (value, p.Value, "B:Value");
  97                         Assert.AreEqual (string.Empty, p.XmlSchemaCollectionDatabase, "B:XmlSchemaCollectionDatabase");
  98                         Assert.AreEqual (string.Empty, p.XmlSchemaCollectionName, "B:XmlSchemaCollectionName");
  99                         Assert.AreEqual (string.Empty, p.XmlSchemaCollectionOwningSchema, "B:XmlSchemaCollectionOwningSchema");
 100                 }
 101
 102                 [Test]
 103 #if FEATURE_NO_BSD_SOCKETS
 104                 [ExpectedException (typeof (PlatformNotSupportedException))]
 105 #endif
 106                 public void Constructor2_Value_DBNull ()
 107                 {
 108                         SqlParameter p = new SqlParameter ("address", DBNull.Value);
 109                         Assert.AreEqual (DbType.String, p.DbType, "B:DbType");
 110                         Assert.AreEqual (ParameterDirection.Input, p.Direction, "B:Direction");
 111                         Assert.IsFalse (p.IsNullable, "B:IsNullable");
 112                         Assert.AreEqual (0, p.LocaleId, "B:LocaleId");
 113                         Assert.AreEqual ("address", p.ParameterName, "B:ParameterName");
 114                         Assert.AreEqual (0, p.Precision, "B:Precision");
 115                         Assert.AreEqual (0, p.Scale, "B:Scale");
 116                         Assert.AreEqual (0, p.Size, "B:Size");
 117                         Assert.AreEqual (string.Empty, p.SourceColumn, "B:SourceColumn");
 118                         Assert.IsFalse (p.SourceColumnNullMapping, "B:SourceColumnNullMapping");
 119                         Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "B:SourceVersion");
 120                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "B:SqlDbType");
 121                         // FIXME
 122                         //Assert.AreEqual (SqlString.Null, p.SqlValue, "B:SqlValue");
 123                         Assert.AreEqual (DBNull.Value, p.Value, "B:Value");
 124                         Assert.AreEqual (string.Empty, p.XmlSchemaCollectionDatabase, "B:XmlSchemaCollectionDatabase");
 125                         Assert.AreEqual (string.Empty, p.XmlSchemaCollectionName, "B:XmlSchemaCollectionName");
 126                         Assert.AreEqual (string.Empty, p.XmlSchemaCollectionOwningSchema, "B:XmlSchemaCollectionOwningSchema");
 127                 }
 128
 129                 [Test]
 130 #if FEATURE_NO_BSD_SOCKETS
 131                 [ExpectedException (typeof (PlatformNotSupportedException))]
 132 #endif
 133                 public void Constructor2_Value_Null ()
 134                 {
 135                         SqlParameter p = new SqlParameter ("address", (Object) null);
 136                         Assert.AreEqual (DbType.String, p.DbType, "A:DbType");
 137                         Assert.AreEqual (ParameterDirection.Input, p.Direction, "A:Direction");
 138                         Assert.IsFalse (p.IsNullable, "A:IsNullable");
 139                         Assert.AreEqual (0, p.LocaleId, "A:LocaleId");
 140                         Assert.AreEqual ("address", p.ParameterName, "A:ParameterName");
 141                         Assert.AreEqual (0, p.Precision, "A:Precision");
 142                         Assert.AreEqual (0, p.Scale, "A:Scale");
 143                         Assert.AreEqual (0, p.Size, "A:Size");
 144                         Assert.AreEqual (string.Empty, p.SourceColumn, "A:SourceColumn");
 145                         Assert.IsFalse (p.SourceColumnNullMapping, "A:SourceColumnNullMapping");
 146                         Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "A:SourceVersion");
 147                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "A:SqlDbType");
 148                         Assert.IsNull (p.SqlValue, "A:SqlValue");
 149                         Assert.IsNull (p.Value, "A:Value");
 150                         Assert.AreEqual (string.Empty, p.XmlSchemaCollectionDatabase, "A:XmlSchemaCollectionDatabase");
 151                         Assert.AreEqual (string.Empty, p.XmlSchemaCollectionName, "A:XmlSchemaCollectionName");
 152                         Assert.AreEqual (string.Empty, p.XmlSchemaCollectionOwningSchema, "A:XmlSchemaCollectionOwningSchema");
 153                 }
 154
 155                 [Test] // .ctor (String, SqlDbType, Int32, ParameterDirection, Byte, Byte, String, DataRowVersion, Boolean, Object, String, String, String)
 156 #if FEATURE_NO_BSD_SOCKETS
 157                 [ExpectedException (typeof (PlatformNotSupportedException))]
 158 #endif
 159                 public void Constructor7 ()
 160                 {
 161                         SqlParameter p1 = new SqlParameter ("p1Name", SqlDbType.VarChar, 20,
 162                                                             ParameterDirection.InputOutput, 0, 0,
 163                                                             "srcCol", DataRowVersion.Original, false,
 164                                                             "foo", "database", "schema", "name");
 165                         Assert.AreEqual (DbType.AnsiString, p1.DbType, "DbType");
 166                         Assert.AreEqual (ParameterDirection.InputOutput, p1.Direction, "Direction");
 167                         Assert.AreEqual (false, p1.IsNullable, "IsNullable");
 168                         //Assert.AreEqual (999, p1.LocaleId, "#");
 169                         Assert.AreEqual ("p1Name", p1.ParameterName, "ParameterName");
 170                         Assert.AreEqual (0, p1.Precision, "Precision");
 171                         Assert.AreEqual (0, p1.Scale, "Scale");
 172                         Assert.AreEqual (20, p1.Size, "Size");
 173                         Assert.AreEqual ("srcCol", p1.SourceColumn, "SourceColumn");
 174                         Assert.AreEqual (false, p1.SourceColumnNullMapping, "SourceColumnNullMapping");
 175                         Assert.AreEqual (DataRowVersion.Original, p1.SourceVersion, "SourceVersion");
 176                         Assert.AreEqual (SqlDbType.VarChar, p1.SqlDbType, "SqlDbType");
 177                         //Assert.AreEqual (3210, p1.SqlValue, "#");
 178                         Assert.AreEqual ("foo", p1.Value, "Value");
 179                         Assert.AreEqual ("database", p1.XmlSchemaCollectionDatabase, "XmlSchemaCollectionDatabase");
 180                         Assert.AreEqual ("name", p1.XmlSchemaCollectionName, "XmlSchemaCollectionName");
 181                         Assert.AreEqual ("schema", p1.XmlSchemaCollectionOwningSchema, "XmlSchemaCollectionOwningSchema");
 182                 }
 183
 184                 [Test]
 185 #if FEATURE_NO_BSD_SOCKETS
 186                 [ExpectedException (typeof (PlatformNotSupportedException))]
 187 #endif
 188                 public void CompareInfo ()
 189                 {
 190                         SqlParameter parameter = new SqlParameter ();
 191                         Assert.AreEqual (SqlCompareOptions.None, parameter.CompareInfo, "#1");
 192                         parameter.CompareInfo = SqlCompareOptions.IgnoreNonSpace;
 193                         Assert.AreEqual (SqlCompareOptions.IgnoreNonSpace, parameter.CompareInfo, "#2");
 194                 }
 195
 196                 [Test]
 197 #if FEATURE_NO_BSD_SOCKETS
 198                 [ExpectedException (typeof (PlatformNotSupportedException))]
 199 #endif
 200                 public void InferType_Byte ()
 201                 {
 202                         Byte value = 0x0a;
 203
 204                         SqlParameter param = new SqlParameter ();
 205                         param.Value = value;
 206                         Assert.AreEqual (SqlDbType.TinyInt, param.SqlDbType, "#1");
 207                         Assert.AreEqual (DbType.Byte, param.DbType, "#2");
 208                 }
 209
 210                 [Test]
 211 #if FEATURE_NO_BSD_SOCKETS
 212                 [ExpectedException (typeof (PlatformNotSupportedException))]
 213 #endif
 214                 public void InferType_ByteArray ()
 215                 {
 216                         Byte [] value = new Byte [] { 0x0a, 0x0d };
 217
 218                         SqlParameter param = new SqlParameter ();
 219                         param.Value = value;
 220                         Assert.AreEqual (SqlDbType.VarBinary, param.SqlDbType, "#1");
 221                         Assert.AreEqual (DbType.Binary, param.DbType, "#2");
 222                 }
 223
 224                 [Test]
 225                 [Category ("NotWorking")]
 226                 public void InferType_Char ()
 227                 {
 228                         Char value = 'X';
 229
 230                         String string_value = "X";
 231
 232                         SqlParameter p = new SqlParameter ();
 233                         p.Value = value;
 234                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#A:SqlDbType");
 235                         Assert.AreEqual (DbType.String, p.DbType, "#A:DbType");
 236                         Assert.AreEqual (string_value, p.Value, "#A:Value");
 237
 238                         p = new SqlParameter ();
 239                         p.Value = value;
 240                         Assert.AreEqual (value, p.Value, "#B:Value1");
 241                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#B:SqlDbType");
 242                         Assert.AreEqual (string_value, p.Value, "#B:Value2");
 243
 244                         p = new SqlParameter ();
 245                         p.Value = value;
 246                         Assert.AreEqual (value, p.Value, "#C:Value1");
 247                         Assert.AreEqual (DbType.String, p.DbType, "#C:DbType");
 248                         Assert.AreEqual (string_value, p.Value, "#C:Value2");
 249
 250                         p = new SqlParameter ("name", value);
 251                         Assert.AreEqual (value, p.Value, "#D:Value1");
 252                         Assert.AreEqual (DbType.String, p.DbType, "#D:DbType");
 253                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#D:SqlDbType");
 254                         Assert.AreEqual (string_value, p.Value, "#D:Value2");
 255
 256                         p = new SqlParameter ("name", 5);
 257                         p.Value = value;
 258                         Assert.AreEqual (value, p.Value, "#E:Value1");
 259                         Assert.AreEqual (DbType.String, p.DbType, "#E:DbType");
 260                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#E:SqlDbType");
 261                         Assert.AreEqual (string_value, p.Value, "#E:Value2");
 262
 263                         p = new SqlParameter ("name", SqlDbType.NVarChar);
 264                         p.Value = value;
 265                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#F:SqlDbType");
 266                         Assert.AreEqual (value, p.Value, "#F:Value");
 267                 }
 268
 269                 [Test]
 270                 [Category ("NotWorking")]
 271                 public void InferType_CharArray ()
 272                 {
 273                         Char [] value = new Char [] { 'A', 'X' };
 274
 275                         String string_value = "AX";
 276
 277                         SqlParameter p = new SqlParameter ();
 278                         p.Value = value;
 279                         Assert.AreEqual (value, p.Value, "#A:Value1");
 280                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#A:SqlDbType");
 281                         Assert.AreEqual (DbType.String, p.DbType, "#A:DbType");
 282                         Assert.AreEqual (string_value, p.Value, "#A:Value2");
 283
 284                         p = new SqlParameter ();
 285                         p.Value = value;
 286                         Assert.AreEqual (value, p.Value, "#B:Value1");
 287                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#B:SqlDbType");
 288                         Assert.AreEqual (string_value, p.Value, "#B:Value2");
 289
 290                         p = new SqlParameter ();
 291                         p.Value = value;
 292                         Assert.AreEqual (value, p.Value, "#C:Value1");
 293                         Assert.AreEqual (DbType.String, p.DbType, "#C:DbType");
 294                         Assert.AreEqual (string_value, p.Value, "#C:Value2");
 295
 296                         p = new SqlParameter ("name", value);
 297                         Assert.AreEqual (value, p.Value, "#D:Value1");
 298                         Assert.AreEqual (DbType.String, p.DbType, "#D:DbType");
 299                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#D:SqlDbType");
 300                         Assert.AreEqual (string_value, p.Value, "#D:Value2");
 301
 302                         p = new SqlParameter ("name", 5);
 303                         p.Value = value;
 304                         Assert.AreEqual (value, p.Value, "#E:Value1");
 305                         Assert.AreEqual (DbType.String, p.DbType, "#E:DbType");
 306                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#E:SqlDbType");
 307                         Assert.AreEqual (string_value, p.Value, "#E:Value2");
 308
 309                         p = new SqlParameter ("name", SqlDbType.NVarChar);
 310                         p.Value = value;
 311                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#F:SqlDbType");
 312                         Assert.AreEqual (value, p.Value, "#F:Value");
 313                 }
 314
 315                 [Test]
 316 #if FEATURE_NO_BSD_SOCKETS
 317                 [ExpectedException (typeof (PlatformNotSupportedException))]
 318 #endif
 319                 public void InferType_DateTime ()
 320                 {
 321                         DateTime value;
 322                         SqlParameter param;
 323
 324                         value = DateTime.Now;
 325                         param = new SqlParameter ();
 326                         param.Value = value;
 327                         Assert.AreEqual (SqlDbType.DateTime, param.SqlDbType, "#A1");
 328                         Assert.AreEqual (DbType.DateTime, param.DbType, "#A2");
 329
 330                         value = DateTime.Now;
 331                         param = new SqlParameter ();
 332                         param.Value = value;
 333                         Assert.AreEqual (SqlDbType.DateTime, param.SqlDbType, "#B1");
 334                         Assert.AreEqual (DbType.DateTime, param.DbType, "#B2");
 335
 336                         value = new DateTime (1973, 8, 13);
 337                         param = new SqlParameter ();
 338                         param.Value = value;
 339                         Assert.AreEqual (SqlDbType.DateTime, param.SqlDbType, "#C1");
 340                         Assert.AreEqual (DbType.DateTime, param.DbType, "#C2");
 341                 }
 342
 343                 [Test]
 344 #if FEATURE_NO_BSD_SOCKETS
 345                 [ExpectedException (typeof (PlatformNotSupportedException))]
 346 #endif
 347                 public void InferType_Decimal ()
 348                 {
 349                         Decimal value;
 350                         SqlParameter param;
 351
 352                         value = Decimal.MaxValue;
 353                         param = new SqlParameter ();
 354                         param.Value = value;
 355                         Assert.AreEqual (SqlDbType.Decimal, param.SqlDbType, "#A1");
 356                         Assert.AreEqual (DbType.Decimal, param.DbType, "#A2");
 357
 358                         value = Decimal.MinValue;
 359                         param = new SqlParameter ();
 360                         param.Value = value;
 361                         Assert.AreEqual (SqlDbType.Decimal, param.SqlDbType, "#B1");
 362                         Assert.AreEqual (DbType.Decimal, param.DbType, "#B2");
 363
 364                         value = 214748.364m;
 365                         param = new SqlParameter ();
 366                         param.Value = value;
 367                         Assert.AreEqual (SqlDbType.Decimal, param.SqlDbType, "#C1");
 368                         Assert.AreEqual (DbType.Decimal, param.DbType, "#C2");
 369                 }
 370
 371                 [Test]
 372 #if FEATURE_NO_BSD_SOCKETS
 373                 [ExpectedException (typeof (PlatformNotSupportedException))]
 374 #endif
 375                 public void InferType_Double ()
 376                 {
 377                         Double value;
 378                         SqlParameter param;
 379
 380                         value = Double.MaxValue;
 381                         param = new SqlParameter ();
 382                         param.Value = value;
 383                         Assert.AreEqual (SqlDbType.Float, param.SqlDbType, "#A1");
 384                         Assert.AreEqual (DbType.Double, param.DbType, "#A2");
 385
 386                         value = Double.MinValue;
 387                         param = new SqlParameter ();
 388                         param.Value = value;
 389                         Assert.AreEqual (SqlDbType.Float, param.SqlDbType, "#B1");
 390                         Assert.AreEqual (DbType.Double, param.DbType, "#B2");
 391
 392                         value = 0d;
 393                         param = new SqlParameter ();
 394                         param.Value = value;
 395                         Assert.AreEqual (SqlDbType.Float, param.SqlDbType, "#C1");
 396                         Assert.AreEqual (DbType.Double, param.DbType, "#C2");
 397                 }
 398
 399                 [Test]
 400 #if FEATURE_NO_BSD_SOCKETS
 401                 [ExpectedException (typeof (PlatformNotSupportedException))]
 402 #endif
 403                 public void InferType_Enum ()
 404                 {
 405                         SqlParameter param;
 406
 407                         param = new SqlParameter ();
 408                         param.Value = ByteEnum.A;
 409                         Assert.AreEqual (SqlDbType.TinyInt, param.SqlDbType, "#A1");
 410                         Assert.AreEqual (DbType.Byte, param.DbType, "#A2");
 411
 412                         param = new SqlParameter ();
 413                         param.Value = Int64Enum.A;
 414                         Assert.AreEqual (SqlDbType.BigInt, param.SqlDbType, "#B1");
 415                         Assert.AreEqual (DbType.Int64, param.DbType, "#B2");
 416                 }
 417
 418                 [Test]
 419 #if FEATURE_NO_BSD_SOCKETS
 420                 [ExpectedException (typeof (PlatformNotSupportedException))]
 421 #endif
 422                 public void InferType_Guid ()
 423                 {
 424                         Guid value = Guid.NewGuid ();
 425
 426                         SqlParameter param = new SqlParameter ();
 427                         param.Value = value;
 428                         Assert.AreEqual (SqlDbType.UniqueIdentifier, param.SqlDbType, "#1");
 429                         Assert.AreEqual (DbType.Guid, param.DbType, "#2");
 430                 }
 431
 432                 [Test]
 433 #if FEATURE_NO_BSD_SOCKETS
 434                 [ExpectedException (typeof (PlatformNotSupportedException))]
 435 #endif
 436                 public void InferType_Int16 ()
 437                 {
 438                         Int16 value;
 439                         SqlParameter param;
 440
 441                         value = Int16.MaxValue;
 442                         param = new SqlParameter ();
 443                         param.Value = value;
 444                         Assert.AreEqual (SqlDbType.SmallInt, param.SqlDbType, "#A1");
 445                         Assert.AreEqual (DbType.Int16, param.DbType, "#A2");
 446
 447                         value = Int16.MinValue;
 448                         param = new SqlParameter ();
 449                         param.Value = value;
 450                         Assert.AreEqual (SqlDbType.SmallInt, param.SqlDbType, "#B1");
 451                         Assert.AreEqual (DbType.Int16, param.DbType, "#B2");
 452
 453                         value = (Int16) 0;
 454                         param = new SqlParameter ();
 455                         param.Value = value;
 456                         Assert.AreEqual (SqlDbType.SmallInt, param.SqlDbType, "#C1");
 457                         Assert.AreEqual (DbType.Int16, param.DbType, "#C2");
 458                 }
 459
 460                 [Test]
 461 #if FEATURE_NO_BSD_SOCKETS
 462                 [ExpectedException (typeof (PlatformNotSupportedException))]
 463 #endif
 464                 public void InferType_Int32 ()
 465                 {
 466                         Int32 value;
 467                         SqlParameter param;
 468
 469                         value = Int32.MaxValue;
 470                         param = new SqlParameter ();
 471                         param.Value = value;
 472                         Assert.AreEqual (SqlDbType.Int, param.SqlDbType, "#A1");
 473                         Assert.AreEqual (DbType.Int32, param.DbType, "#A2");
 474
 475                         value = Int32.MinValue;
 476                         param = new SqlParameter ();
 477                         param.Value = value;
 478                         Assert.AreEqual (SqlDbType.Int, param.SqlDbType, "#B1");
 479                         Assert.AreEqual (DbType.Int32, param.DbType, "#B2");
 480
 481                         value = 0;
 482                         param = new SqlParameter ();
 483                         param.Value = value;
 484                         Assert.AreEqual (SqlDbType.Int, param.SqlDbType, "#C1");
 485                         Assert.AreEqual (DbType.Int32, param.DbType, "#C2");
 486                 }
 487
 488                 [Test]
 489 #if FEATURE_NO_BSD_SOCKETS
 490                 [ExpectedException (typeof (PlatformNotSupportedException))]
 491 #endif
 492                 public void InferType_Int64 ()
 493                 {
 494                         Int64 value;
 495                         SqlParameter param;
 496
 497                         value = Int64.MaxValue;
 498                         param = new SqlParameter ();
 499                         param.Value = value;
 500                         Assert.AreEqual (SqlDbType.BigInt, param.SqlDbType, "#A1");
 501                         Assert.AreEqual (DbType.Int64, param.DbType, "#A2");
 502
 503                         value = Int64.MinValue;
 504                         param = new SqlParameter ();
 505                         param.Value = value;
 506                         Assert.AreEqual (SqlDbType.BigInt, param.SqlDbType, "#B1");
 507                         Assert.AreEqual (DbType.Int64, param.DbType, "#B2");
 508
 509                         value = 0L;
 510                         param = new SqlParameter ();
 511                         param.Value = value;
 512                         Assert.AreEqual (SqlDbType.BigInt, param.SqlDbType, "#C1");
 513                         Assert.AreEqual (DbType.Int64, param.DbType, "#C2");
 514                 }
 515
 516                 [Test]
 517                 [Category ("NotWorking")]
 518                 public void InferType_Invalid ()
 519                 {
 520                         object [] notsupported = new object [] {
 521                                 UInt16.MaxValue,
 522                                 UInt32.MaxValue,
 523                                 UInt64.MaxValue,
 524                                 SByte.MaxValue,
 525                                 new SqlParameter ()
 526                         };
 527
 528                         SqlParameter param = new SqlParameter ();
 529
 530                         for (int i = 0; i < notsupported.Length; i++) {
 531                                 param.Value = notsupported [i];
 532                                 try {
 533                                         SqlDbType type = param.SqlDbType;
 534                                         Assert.Fail ("#A1:" + i + " (" + type + ")");
 535                                 } catch (ArgumentException ex) {
 536                                         // The parameter data type of ... is invalid
 537                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 538                                         Assert.IsNull (ex.InnerException, "#A3");
 539                                         Assert.IsNotNull (ex.Message, "#A4");
 540                                         Assert.IsNull (ex.ParamName, "#A5");
 541                                 }
 542
 543                                 try {
 544                                         DbType type = param.DbType;
 545                                         Assert.Fail ("#B1:" + i + " (" + type + ")");
 546                                 } catch (ArgumentException ex) {
 547                                         // The parameter data type of ... is invalid
 548                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 549                                         Assert.IsNull (ex.InnerException, "#B3");
 550                                         Assert.IsNotNull (ex.Message, "#B4");
 551                                         Assert.IsNull (ex.ParamName, "#B5");
 552                                 }
 553                         }
 554                 }
 555
 556                 [Test]
 557 #if FEATURE_NO_BSD_SOCKETS
 558                 [ExpectedException (typeof (PlatformNotSupportedException))]
 559 #endif
 560                 public void InferType_Object ()
 561                 {
 562                         Object value = new Object ();
 563
 564                         SqlParameter param = new SqlParameter ();
 565                         param.Value = value;
 566                         Assert.AreEqual (SqlDbType.Variant, param.SqlDbType, "#1");
 567                         Assert.AreEqual (DbType.Object, param.DbType, "#2");
 568                 }
 569
 570                 [Test]
 571 #if FEATURE_NO_BSD_SOCKETS
 572                 [ExpectedException (typeof (PlatformNotSupportedException))]
 573 #endif
 574                 public void InferType_Single ()
 575                 {
 576                         Single value = Single.MaxValue;
 577
 578                         SqlParameter param = new SqlParameter ();
 579                         param.Value = value;
 580                         Assert.AreEqual (SqlDbType.Real, param.SqlDbType, "#1");
 581                         Assert.AreEqual (DbType.Single, param.DbType, "#2");
 582                 }
 583
 584                 [Test]
 585 #if FEATURE_NO_BSD_SOCKETS
 586                 [ExpectedException (typeof (PlatformNotSupportedException))]
 587 #endif
 588                 public void InferType_String ()
 589                 {
 590                         String value = "some text";
 591
 592                         SqlParameter param = new SqlParameter ();
 593                         param.Value = value;
 594                         Assert.AreEqual (SqlDbType.NVarChar, param.SqlDbType, "#1");
 595                         Assert.AreEqual (DbType.String, param.DbType, "#2");
 596                 }
 597
 598                 [Test]
 599                 [Category ("NotWorking")]
 600                 public void InferType_TimeSpan ()
 601                 {
 602                         TimeSpan value = new TimeSpan (4, 6, 23);
 603
 604                         SqlParameter param = new SqlParameter ();
 605                         param.Value = value;
 606                         Assert.AreEqual (SqlDbType.Time, param.SqlDbType, "#1");
 607                         Assert.AreEqual (DbType.Time, param.DbType, "#2");
 608                 }
 609
 610                 [Test]
 611 #if FEATURE_NO_BSD_SOCKETS
 612                 [ExpectedException (typeof (PlatformNotSupportedException))]
 613 #endif
 614                 public void LocaleId ()
 615                 {
 616                         SqlParameter parameter = new SqlParameter ();
 617                         Assert.AreEqual (0, parameter.LocaleId, "#1");
 618                         parameter.LocaleId = 15;
 619                         Assert.AreEqual(15, parameter.LocaleId, "#2");
 620                 }
 621
 622                 [Test] // bug #320196
 623 #if FEATURE_NO_BSD_SOCKETS
 624                 [ExpectedException (typeof (PlatformNotSupportedException))]
 625 #endif
 626                 public void ParameterNullTest ()
 627                 {
 628                         SqlParameter param = new SqlParameter ("param", SqlDbType.Decimal);
 629                         Assert.AreEqual (0, param.Scale, "#A1");
 630                         param.Value = DBNull.Value;
 631                         Assert.AreEqual (0, param.Scale, "#A2");
 632
 633                         param = new SqlParameter ("param", SqlDbType.Int);
 634                         Assert.AreEqual (0, param.Scale, "#B1");
 635                         param.Value = DBNull.Value;
 636                         Assert.AreEqual (0, param.Scale, "#B2");
 637                 }
 638
 639                 [Test]
 640 #if FEATURE_NO_BSD_SOCKETS
 641                 [ExpectedException (typeof (PlatformNotSupportedException))]
 642 #endif
 643                 public void ParameterType ()
 644                 {
 645                         SqlParameter p;
 646
 647                         // If Type is not set, then type is inferred from the value
 648                         // assigned. The Type should be inferred everytime Value is assigned
 649                         // If value is null or DBNull, then the current Type should be reset to NVarChar.
 650                         p = new SqlParameter ();
 651                         Assert.AreEqual (DbType.String, p.DbType, "#A1");
 652                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#A2");
 653                         p.Value = DBNull.Value;
 654                         Assert.AreEqual (DbType.String, p.DbType, "#B1");
 655                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#B2");
 656                         p.Value = 1;
 657                         Assert.AreEqual (DbType.Int32, p.DbType, "#C1");
 658                         Assert.AreEqual (SqlDbType.Int, p.SqlDbType, "#C2");
 659                         p.Value = DBNull.Value;
 660                         Assert.AreEqual (DbType.String, p.DbType, "#D1");
 661                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#D2");
 662                         p.Value = new byte [] { 0x0a };
 663                         Assert.AreEqual (DbType.Binary, p.DbType, "#E1");
 664                         Assert.AreEqual (SqlDbType.VarBinary, p.SqlDbType, "#E2");
 665                         p.Value = null;
 666                         Assert.AreEqual (DbType.String, p.DbType, "#F1");
 667                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#F2");
 668                         p.Value = DateTime.Now;
 669                         Assert.AreEqual (DbType.DateTime, p.DbType, "#G1");
 670                         Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#G2");
 671                         p.Value = null;
 672                         Assert.AreEqual (DbType.String, p.DbType, "#H1");
 673                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#H2");
 674
 675                         // If DbType is set, then the SqlDbType should not be
 676                         // inferred from the value assigned.
 677                         p = new SqlParameter ();
 678                         p.DbType = DbType.DateTime;
 679                         Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#I1");
 680                         p.Value = 1;
 681                         Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#I2");
 682                         p.Value = null;
 683                         Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#I3");
 684                         p.Value = DBNull.Value;
 685                         Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#I4");
 686
 687                         // If SqlDbType is set, then the DbType should not be
 688                         // inferred from the value assigned.
 689                         p = new SqlParameter ();
 690                         p.SqlDbType = SqlDbType.VarBinary;
 691                         Assert.AreEqual (SqlDbType.VarBinary, p.SqlDbType, "#J1");
 692                         p.Value = 1;
 693                         Assert.AreEqual (SqlDbType.VarBinary, p.SqlDbType, "#J2");
 694                         p.Value = null;
 695                         Assert.AreEqual (SqlDbType.VarBinary, p.SqlDbType, "#J3");
 696                         p.Value = DBNull.Value;
 697                         Assert.AreEqual (SqlDbType.VarBinary, p.SqlDbType, "#J4");
 698                 }
 699
 700                 [Test]
 701 #if FEATURE_NO_BSD_SOCKETS
 702                 [ExpectedException (typeof (PlatformNotSupportedException))]
 703 #endif
 704                 public void InferType_Boolean ()
 705                 {
 706                         Boolean value;
 707                         SqlParameter param;
 708
 709                         value = false;
 710                         param = new SqlParameter ();
 711                         param.Value = value;
 712                         Assert.AreEqual (SqlDbType.Bit, param.SqlDbType, "#A1");
 713                         Assert.AreEqual (DbType.Boolean, param.DbType, "#A2");
 714
 715                         value = true;
 716                         param = new SqlParameter ();
 717                         param.Value = value;
 718                         Assert.AreEqual (SqlDbType.Bit, param.SqlDbType, "#B1");
 719                         Assert.AreEqual (DbType.Boolean, param.DbType, "#B2");
 720                 }
 721
 722                 [Test]
 723 #if FEATURE_NO_BSD_SOCKETS
 724                 [ExpectedException (typeof (PlatformNotSupportedException))]
 725 #endif
 726                 public void ParameterName ()
 727                 {
 728                         SqlParameter p = new SqlParameter ();
 729                         p.ParameterName = "name";
 730                         Assert.AreEqual ("name", p.ParameterName, "#A:ParameterName");
 731                         Assert.AreEqual (string.Empty, p.SourceColumn, "#A:SourceColumn");
 732
 733                         p.ParameterName = null;
 734                         Assert.AreEqual (string.Empty, p.ParameterName, "#B:ParameterName");
 735                         Assert.AreEqual (string.Empty, p.SourceColumn, "#B:SourceColumn");
 736
 737                         p.ParameterName = " ";
 738                         Assert.AreEqual (" ", p.ParameterName, "#C:ParameterName");
 739                         Assert.AreEqual (string.Empty, p.SourceColumn, "#C:SourceColumn");
 740
 741                         p.ParameterName = " name ";
 742                         Assert.AreEqual (" name ", p.ParameterName, "#D:ParameterName");
 743                         Assert.AreEqual (string.Empty, p.SourceColumn, "#D:SourceColumn");
 744
 745                         p.ParameterName = string.Empty;
 746                         Assert.AreEqual (string.Empty, p.ParameterName, "#E:ParameterName");
 747                         Assert.AreEqual (string.Empty, p.SourceColumn, "#E:SourceColumn");
 748                 }
 749
 750                 [Test]
 751 #if FEATURE_NO_BSD_SOCKETS
 752                 [ExpectedException (typeof (PlatformNotSupportedException))]
 753 #endif
 754                 public void ResetDbType ()
 755                 {
 756                         SqlParameter p;
 757
 758                         //Parameter with an assigned value but no DbType specified
 759                         p = new SqlParameter ("foo", 42);
 760                         p.ResetDbType ();
 761                         Assert.AreEqual (DbType.Int32, p.DbType, "#A:DbType");
 762                         Assert.AreEqual (SqlDbType.Int, p.SqlDbType, "#A:SqlDbType");
 763                         Assert.AreEqual (42, p.Value, "#A:Value");
 764
 765                         p.DbType = DbType.DateTime; //assigning a DbType
 766                         Assert.AreEqual (DbType.DateTime, p.DbType, "#B:DbType1");
 767                         Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#B:SqlDbType1");
 768                         p.ResetDbType ();
 769                         Assert.AreEqual (DbType.Int32, p.DbType, "#B:DbType2");
 770                         Assert.AreEqual (SqlDbType.Int, p.SqlDbType, "#B:SqlDbtype2");
 771
 772                         //Parameter with an assigned SqlDbType but no specified value
 773                         p = new SqlParameter ("foo", SqlDbType.Int);
 774                         p.ResetDbType ();
 775                         Assert.AreEqual (DbType.String, p.DbType, "#C:DbType");
 776                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#C:SqlDbType");
 777
 778                         p.DbType = DbType.DateTime; //assigning a SqlDbType
 779                         Assert.AreEqual (DbType.DateTime, p.DbType, "#D:DbType1");
 780                         Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#D:SqlDbType1");
 781                         p.ResetDbType ();
 782                         Assert.AreEqual (DbType.String, p.DbType, "#D:DbType2");
 783                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#D:SqlDbType2");
 784
 785                         p = new SqlParameter ();
 786                         p.Value = DateTime.MaxValue;
 787                         Assert.AreEqual (DbType.DateTime, p.DbType, "#E:DbType1");
 788                         Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#E:SqlDbType1");
 789                         p.Value = null;
 790                         p.ResetDbType ();
 791                         Assert.AreEqual (DbType.String, p.DbType, "#E:DbType2");
 792                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#E:SqlDbType2");
 793
 794                         p = new SqlParameter ("foo", SqlDbType.VarChar);
 795                         p.Value = DateTime.MaxValue;
 796                         p.ResetDbType ();
 797                         Assert.AreEqual (DbType.DateTime, p.DbType, "#F:DbType");
 798                         Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#F:SqlDbType");
 799                         Assert.AreEqual (DateTime.MaxValue, p.Value, "#F:Value");
 800
 801                         p = new SqlParameter ("foo", SqlDbType.VarChar);
 802                         p.Value = DBNull.Value;
 803                         p.ResetDbType ();
 804                         Assert.AreEqual (DbType.String, p.DbType, "#G:DbType");
 805                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#G:SqlDbType");
 806                         Assert.AreEqual (DBNull.Value, p.Value, "#G:Value");
 807
 808                         p = new SqlParameter ("foo", SqlDbType.VarChar);
 809                         p.Value = null;
 810                         p.ResetDbType ();
 811                         Assert.AreEqual (DbType.String, p.DbType, "#G:DbType");
 812                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#G:SqlDbType");
 813                         Assert.IsNull (p.Value, "#G:Value");
 814                 }
 815
 816                 [Test]
 817 #if FEATURE_NO_BSD_SOCKETS
 818                 [ExpectedException (typeof (PlatformNotSupportedException))]
 819 #endif
 820                 public void ResetSqlDbType ()
 821                 {
 822                         //Parameter with an assigned value but no SqlDbType specified
 823                         SqlParameter p1 = new SqlParameter ("foo", 42);
 824                         Assert.AreEqual (42, p1.Value, "#1");
 825                         Assert.AreEqual (DbType.Int32, p1.DbType, "#2");
 826                         Assert.AreEqual (SqlDbType.Int, p1.SqlDbType, "#3");
 827
 828                         p1.ResetSqlDbType ();
 829                         Assert.AreEqual (DbType.Int32, p1.DbType, "#4 The parameter with value 42 must have DbType as Int32");
 830                         Assert.AreEqual (SqlDbType.Int, p1.SqlDbType, "#5 The parameter with value 42 must have SqlDbType as Int");
 831
 832                         p1.SqlDbType = SqlDbType.DateTime; //assigning a SqlDbType
 833                         Assert.AreEqual (DbType.DateTime, p1.DbType, "#6");
 834                         Assert.AreEqual (SqlDbType.DateTime, p1.SqlDbType, "#7");
 835                         p1.ResetSqlDbType (); //Resetting SqlDbType
 836                         Assert.AreEqual (DbType.Int32, p1.DbType, "#8 Resetting SqlDbType must infer the type from the value");
 837                         Assert.AreEqual (SqlDbType.Int, p1.SqlDbType, "#9 Resetting SqlDbType must infer the type from the value");
 838
 839                         //Parameter with an assigned SqlDbType but no specified value
 840                         SqlParameter p2 = new SqlParameter ("foo", SqlDbType.Int);
 841                         Assert.AreEqual (null, p2.Value, "#10");
 842                         Assert.AreEqual (DbType.Int32, p2.DbType, "#11");
 843                         Assert.AreEqual (SqlDbType.Int, p2.SqlDbType, "#12");
 844
 845                         //Although a SqlDbType is specified, calling ResetSqlDbType resets
 846                         //the SqlDbType and DbType properties to default values
 847                         p2.ResetSqlDbType ();
 848                         Assert.AreEqual (DbType.String, p2.DbType, "#13 Resetting SqlDbType must infer the type from the value");
 849                         Assert.AreEqual (SqlDbType.NVarChar, p2.SqlDbType, "#14 Resetting SqlDbType must infer the type from the value");
 850
 851                         p2.SqlDbType = SqlDbType.DateTime; //assigning a SqlDbType
 852                         Assert.AreEqual (DbType.DateTime, p2.DbType, "#15");
 853                         Assert.AreEqual (SqlDbType.DateTime, p2.SqlDbType, "#16");
 854                         p2.ResetSqlDbType (); //Resetting SqlDbType
 855                         Assert.AreEqual (DbType.String, p2.DbType, "#17 Resetting SqlDbType must infer the type from the value");
 856                         Assert.AreEqual (SqlDbType.NVarChar, p2.SqlDbType, "#18 Resetting SqlDbType must infer the type from the value");
 857                 }
 858
 859                 [Test]
 860 #if FEATURE_NO_BSD_SOCKETS
 861                 [ExpectedException (typeof (PlatformNotSupportedException))]
 862 #endif
 863                 public void SourceColumn ()
 864                 {
 865                         SqlParameter p = new SqlParameter ();
 866                         p.SourceColumn = "name";
 867                         Assert.AreEqual (string.Empty, p.ParameterName, "#A:ParameterName");
 868                         Assert.AreEqual ("name", p.SourceColumn, "#A:SourceColumn");
 869
 870                         p.SourceColumn = null;
 871                         Assert.AreEqual (string.Empty, p.ParameterName, "#B:ParameterName");
 872                         Assert.AreEqual (string.Empty, p.SourceColumn, "#B:SourceColumn");
 873
 874                         p.SourceColumn = " ";
 875                         Assert.AreEqual (string.Empty, p.ParameterName, "#C:ParameterName");
 876                         Assert.AreEqual (" ", p.SourceColumn, "#C:SourceColumn");
 877
 878                         p.SourceColumn = " name ";
 879                         Assert.AreEqual (string.Empty, p.ParameterName, "#D:ParameterName");
 880                         Assert.AreEqual (" name ", p.SourceColumn, "#D:SourceColumn");
 881
 882                         p.SourceColumn = string.Empty;
 883                         Assert.AreEqual (string.Empty, p.ParameterName, "#E:ParameterName");
 884                         Assert.AreEqual (string.Empty, p.SourceColumn, "#E:SourceColumn");
 885                 }
 886
 887                 [Test]
 888 #if FEATURE_NO_BSD_SOCKETS
 889                 [ExpectedException (typeof (PlatformNotSupportedException))]
 890 #endif
 891                 public void SourceColumnNullMapping ()
 892                 {
 893                         SqlParameter p = new SqlParameter ();
 894                         Assert.IsFalse (p.SourceColumnNullMapping, "#1");
 895                         p.SourceColumnNullMapping = true;
 896                         Assert.IsTrue (p.SourceColumnNullMapping, "#2");
 897                         p.SourceColumnNullMapping = false;
 898                         Assert.IsFalse (p.SourceColumnNullMapping, "#3");
 899                 }
 900
 901                 [Test]
 902 #if FEATURE_NO_BSD_SOCKETS
 903                 [ExpectedException (typeof (PlatformNotSupportedException))]
 904 #endif
 905                 public void SqlDbTypeTest ()
 906                 {
 907                         SqlParameter p = new SqlParameter ("zipcode", 3510);
 908                         p.SqlDbType = SqlDbType.DateTime;
 909                         Assert.AreEqual (DbType.DateTime, p.DbType, "#A:DbType");
 910                         Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#A:SqlDbType");
 911                         Assert.AreEqual (3510, p.Value, "#A:Value");
 912                         p.SqlDbType = SqlDbType.VarChar;
 913                         Assert.AreEqual (DbType.AnsiString, p.DbType, "#B:DbType");
 914                         Assert.AreEqual (SqlDbType.VarChar, p.SqlDbType, "#B:SqlDbType");
 915                         Assert.AreEqual (3510, p.Value, "#B:Value");
 916                 }
 917
 918                 [Test]
 919 #if FEATURE_NO_BSD_SOCKETS
 920                 [ExpectedException (typeof (PlatformNotSupportedException))]
 921 #endif
 922                 public void SqlDbTypeTest_Value_Invalid ()
 923                 {
 924                         SqlParameter p = new SqlParameter ("zipcode", 3510);
 925                         try {
 926                                 p.SqlDbType = (SqlDbType) 666;
 927                                 Assert.Fail ("#1");
 928                         } catch (ArgumentOutOfRangeException ex) {
 929                                 // The SqlDbType enumeration value, 666, is
 930                                 // invalid
 931                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
 932                                 Assert.IsNull (ex.InnerException, "#3");
 933                                 Assert.IsNotNull (ex.Message, "#4");
 934                                 Assert.IsTrue (ex.Message.IndexOf ("666") != -1, "#5:" + ex.Message);
 935                                 Assert.AreEqual ("SqlDbType", ex.ParamName, "#6");
 936                         }
 937                 }
 938
 939                 [Test]
 940 #if FEATURE_NO_BSD_SOCKETS
 941                 [ExpectedException (typeof (PlatformNotSupportedException))]
 942 #endif
 943                 public void SqlValue ()
 944                 {
 945                         SqlParameter parameter = new SqlParameter ();
 946                         Assert.IsNull (parameter.SqlValue, "#A1");
 947
 948                         object value;
 949
 950                         value = "Char";
 951                         parameter.SqlValue = value;
 952                         Assert.AreEqual (SqlDbType.NVarChar, parameter.SqlDbType, "String:SqlDbType");
 953                         Assert.IsNotNull (parameter.SqlValue, "String:SqlValue1");
 954                         Assert.AreEqual (typeof (SqlString), parameter.SqlValue.GetType (), "String:SqlValue2");
 955                         Assert.AreEqual (value, ((SqlString) parameter.SqlValue).Value, "String:SqlValue3");
 956                         Assert.AreEqual (value, parameter.Value, "String:Value");
 957
 958                         value = true;
 959                         parameter.SqlValue = value;
 960                         Assert.AreEqual (SqlDbType.Bit, parameter.SqlDbType, "Boolean:SqlDbType");
 961                         Assert.IsNotNull (parameter.SqlValue, "Boolean:SqlValue1");
 962                         Assert.AreEqual (typeof (SqlBoolean), parameter.SqlValue.GetType (), "Boolean:SqlValue2");
 963                         Assert.AreEqual (value, ((SqlBoolean) parameter.SqlValue).Value, "Boolean:SqlValue3");
 964                         Assert.AreEqual (value, parameter.Value, "Boolean:Value");
 965
 966                         value = (byte) 0x0a;
 967                         parameter.SqlValue = value;
 968                         Assert.AreEqual (SqlDbType.TinyInt, parameter.SqlDbType, "Boolean:SqlDbType");
 969                         Assert.IsNotNull (parameter.SqlValue, "Boolean:SqlValue1");
 970                         Assert.AreEqual (typeof (SqlByte), parameter.SqlValue.GetType (), "Boolean:SqlValue2");
 971                         Assert.AreEqual (value, ((SqlByte) parameter.SqlValue).Value, "Boolean:SqlValue3");
 972                         Assert.AreEqual (value, parameter.Value, "Boolean:Value");
 973
 974                         value = new DateTime (2008, 6, 4);
 975                         parameter.SqlValue = value;
 976                         Assert.AreEqual (SqlDbType.DateTime, parameter.SqlDbType, "DateTime:SqlDbType");
 977                         Assert.IsNotNull (parameter.SqlValue, "DateTime:SqlValue1");
 978                         Assert.AreEqual (typeof (SqlDateTime), parameter.SqlValue.GetType (), "DateTime:SqlValue2");
 979                         Assert.AreEqual (value, ((SqlDateTime) parameter.SqlValue).Value, "DateTime:SqlValue3");
 980                         Assert.AreEqual (value, parameter.Value, "DateTime:Value");
 981
 982                         value = Guid.NewGuid ();
 983                         parameter.SqlValue = value;
 984                         Assert.AreEqual (SqlDbType.UniqueIdentifier, parameter.SqlDbType, "Guid:SqlDbType");
 985                         Assert.IsNotNull (parameter.SqlValue, "Guid:SqlValue1");
 986                         Assert.AreEqual (typeof (SqlGuid), parameter.SqlValue.GetType (), "Guid:SqlValue2");
 987                         Assert.AreEqual (value, ((SqlGuid) parameter.SqlValue).Value, "Guid:SqlValue3");
 988                         Assert.AreEqual (value, parameter.Value, "Guid:Value");
 989
 990                         value = (short) 5;
 991                         parameter.SqlValue = value;
 992                         Assert.AreEqual (SqlDbType.SmallInt, parameter.SqlDbType, "Int16:SqlDbType");
 993                         Assert.IsNotNull (parameter.SqlValue, "Int16:SqlValue1");
 994                         Assert.AreEqual (typeof (SqlInt16), parameter.SqlValue.GetType (), "Int16:SqlValue2");
 995                         Assert.AreEqual (value, ((SqlInt16) parameter.SqlValue).Value, "Int16:SqlValue3");
 996                         Assert.AreEqual (value, parameter.Value, "Int16:Value");
 997
 998                         value = 10;
 999                         parameter.SqlValue = value;
1000                         Assert.AreEqual (SqlDbType.Int, parameter.SqlDbType, "Int32:SqlDbType");
1001                         Assert.IsNotNull (parameter.SqlValue, "Int32:SqlValue1");
1002                         Assert.AreEqual (typeof (SqlInt32), parameter.SqlValue.GetType (), "Int32:SqlValue2");
1003                         Assert.AreEqual (value, ((SqlInt32) parameter.SqlValue).Value, "Int32:SqlValue3");
1004                         Assert.AreEqual (value, parameter.Value, "Int32:Value");
1005
1006                         value = 56L;
1007                         parameter.SqlValue = value;
1008                         Assert.AreEqual (SqlDbType.BigInt, parameter.SqlDbType, "Int64:SqlDbType");
1009                         Assert.IsNotNull (parameter.SqlValue, "Int64:SqlValue1");
1010                         Assert.AreEqual (typeof (SqlInt64), parameter.SqlValue.GetType (), "Int64:SqlValue2");
1011                         Assert.AreEqual (value, ((SqlInt64) parameter.SqlValue).Value, "Int64:SqlValue3");
1012                         Assert.AreEqual (value, parameter.Value, "Int64:Value");
1013
1014                         parameter.SqlValue = 45.5D;
1015                         Assert.AreEqual (SqlDbType.Float, parameter.SqlDbType, "Double:SqlDbType");
1016                         Assert.IsNotNull (parameter.SqlValue, "Double:SqlValue1");
1017                         Assert.AreEqual (typeof (SqlDouble), parameter.SqlValue.GetType (), "Double:SqlValue2");
1018                         Assert.AreEqual (45.5D, ((SqlDouble) parameter.SqlValue).Value, "Double:SqlValue3");
1019                         Assert.AreEqual (45.5D, parameter.Value, "Double:Value");
1020
1021                         value = 45m;
1022                         parameter.SqlValue = value;
1023                         Assert.AreEqual (SqlDbType.Decimal, parameter.SqlDbType, "Decimal:SqlDbType");
1024                         Assert.IsNotNull (parameter.SqlValue, "Decimal:SqlValue1");
1025                         Assert.AreEqual (typeof (SqlDecimal), parameter.SqlValue.GetType (), "Decimal:SqlValue2");
1026                         Assert.AreEqual (value, ((SqlDecimal) parameter.SqlValue).Value, "Decimal:SqlValue3");
1027                         Assert.AreEqual (value, parameter.Value, "Decimal:Value");
1028
1029                         value = 45f;
1030                         parameter.SqlValue = value;
1031                         Assert.AreEqual (SqlDbType.Real, parameter.SqlDbType, "Decimal:SqlDbType");
1032                         Assert.IsNotNull (parameter.SqlValue, "Decimal:SqlValue1");
1033                         Assert.AreEqual (typeof (SqlSingle), parameter.SqlValue.GetType (), "Decimal:SqlValue2");
1034                         Assert.AreEqual (value, ((SqlSingle) parameter.SqlValue).Value, "Decimal:SqlValue3");
1035                         Assert.AreEqual (value, parameter.Value, "Decimal:Value");
1036
1037                         value = new byte [] { 0x0d, 0x0a };
1038                         parameter.SqlValue = value;
1039                         Assert.AreEqual (SqlDbType.VarBinary, parameter.SqlDbType, "Bytes:SqlDbType");
1040                         Assert.IsNotNull (parameter.SqlValue, "Bytes:SqlValue1");
1041                         Assert.AreEqual (typeof (SqlBinary), parameter.SqlValue.GetType (), "Bytes:SqlValue2");
1042                         Assert.AreEqual (value, ((SqlBinary) parameter.SqlValue).Value, "Bytes:SqlValue3");
1043                         Assert.AreEqual (value, parameter.Value, "Bytes:Value");
1044
1045                         parameter = new SqlParameter ();
1046                         value = 'X';
1047                         parameter.SqlValue = value;
1048                         Assert.AreEqual (SqlDbType.NVarChar, parameter.SqlDbType, "Chars:SqlDbType");
1049                         Assert.IsNotNull (parameter.SqlValue, "Chars:SqlValue1");
1050                         Assert.AreEqual (typeof (SqlString), parameter.SqlValue.GetType (), "Chars:SqlValue2");
1051                         Assert.AreEqual ("X", ((SqlString) parameter.SqlValue).Value, "Chars:SqlValue3");
1052                         // FIXME bug #525321
1053                         //Assert.AreEqual ("X", parameter.Value, "Chars:Value");
1054
1055                         value = new char [] { 'X', 'A' };
1056                         parameter.SqlValue = value;
1057                         Assert.AreEqual (SqlDbType.NVarChar, parameter.SqlDbType, "Chars:SqlDbType");
1058                         Assert.IsNotNull (parameter.SqlValue, "Chars:SqlValue1");
1059                         Assert.AreEqual (typeof (SqlString), parameter.SqlValue.GetType (), "Chars:SqlValue2");
1060                         Assert.AreEqual ("XA", ((SqlString) parameter.SqlValue).Value, "Chars:SqlValue3");
1061                         // FIXME bug #525321
1062                         //Assert.AreEqual ("XA", parameter.Value, "Chars:Value");
1063                 }
1064
1065                 [Test]
1066 #if FEATURE_NO_BSD_SOCKETS
1067                 [ExpectedException (typeof (PlatformNotSupportedException))]
1068 #endif
1069                 public void SqlTypes_SqlBinary ()
1070                 {
1071                         SqlParameter parameter;
1072                         SqlBinary value = new SqlBinary (new byte [] { 0x0d, 0x0a });
1073
1074                         parameter = new SqlParameter ();
1075                         parameter.SqlValue = value;
1076                         Assert.AreEqual (SqlDbType.VarBinary, parameter.SqlDbType, "#A:SqlDbType");
1077                         Assert.AreEqual (value, parameter.SqlValue, "#A:SqlValue");
1078                         Assert.AreEqual (value, parameter.Value, "#A:Value");
1079
1080                         parameter = new SqlParameter ();
1081                         parameter.SqlValue = SqlBinary.Null;
1082                         Assert.AreEqual (SqlDbType.VarBinary, parameter.SqlDbType, "#B:SqlDbType");
1083                         Assert.AreEqual (SqlBinary.Null, parameter.SqlValue, "#B:SqlValue");
1084                         Assert.AreEqual (SqlBinary.Null, parameter.Value, "#B:Value");
1085
1086                         parameter = new SqlParameter ();
1087                         parameter.Value = value;
1088                         Assert.AreEqual (SqlDbType.VarBinary, parameter.SqlDbType, "#C:SqlDbType");
1089                         Assert.AreEqual (value, parameter.SqlValue, "#C:SqlValue");
1090                         Assert.AreEqual (value, parameter.Value, "#C:Value");
1091                 }
1092
1093                 [Test]
1094 #if FEATURE_NO_BSD_SOCKETS
1095                 [ExpectedException (typeof (PlatformNotSupportedException))]
1096 #endif
1097                 public void SqlTypes_SqlBoolean ()
1098                 {
1099                         SqlParameter parameter;
1100                         SqlBoolean value = new SqlBoolean (false);
1101
1102                         parameter = new SqlParameter ();
1103                         parameter.SqlValue = value;
1104                         Assert.AreEqual (SqlDbType.Bit, parameter.SqlDbType, "#A:SqlDbType");
1105                         Assert.AreEqual (value, parameter.SqlValue, "#A:SqlValue");
1106                         Assert.AreEqual (value, parameter.Value, "#A:Value");
1107
1108                         parameter = new SqlParameter ();
1109                         parameter.SqlValue = SqlBoolean.Null;
1110                         Assert.AreEqual (SqlDbType.Bit, parameter.SqlDbType, "#B:SqlDbType");
1111                         Assert.AreEqual (SqlBoolean.Null, parameter.SqlValue, "#B:SqlValue");
1112                         Assert.AreEqual (SqlBoolean.Null, parameter.Value, "#B:Value");
1113
1114                         parameter = new SqlParameter ();
1115                         parameter.Value = value;
1116                         Assert.AreEqual (SqlDbType.Bit, parameter.SqlDbType, "#C:SqlDbType");
1117                         Assert.AreEqual (value, parameter.SqlValue, "#C:SqlValue");
1118                         Assert.AreEqual (value, parameter.Value, "#C:Value");
1119                 }
1120
1121                 [Test]
1122 #if FEATURE_NO_BSD_SOCKETS
1123                 [ExpectedException (typeof (PlatformNotSupportedException))]
1124 #endif
1125                 public void SqlTypes_SqlByte ()
1126                 {
1127                         SqlParameter parameter;
1128                         SqlByte value = new SqlByte (0x0d);
1129
1130                         parameter = new SqlParameter ();
1131                         parameter.SqlValue = value;
1132                         Assert.AreEqual (SqlDbType.TinyInt, parameter.SqlDbType, "#A:SqlDbType");
1133                         Assert.AreEqual (value, parameter.SqlValue, "#A:SqlValue");
1134                         Assert.AreEqual (value, parameter.Value, "#A:Value");
1135
1136                         parameter = new SqlParameter ();
1137                         parameter.SqlValue = SqlByte.Null;
1138                         Assert.AreEqual (SqlDbType.TinyInt, parameter.SqlDbType, "#B:SqlDbType");
1139                         Assert.AreEqual (SqlByte.Null, parameter.SqlValue, "#B:SqlValue");
1140                         Assert.AreEqual (SqlByte.Null, parameter.Value, "#B:Value");
1141
1142                         parameter = new SqlParameter ();
1143                         parameter.Value = value;
1144                         Assert.AreEqual (SqlDbType.TinyInt, parameter.SqlDbType, "#C:SqlDbType");
1145                         Assert.AreEqual (value, parameter.SqlValue, "#C:SqlValue");
1146                         Assert.AreEqual (value, parameter.Value, "#C:Value");
1147                 }
1148
1149                 [Test]
1150                 [Category ("NotWorking")]
1151                 // This doesn't work as SqlBytes are represented as SqlBinary
1152                 public void SqlTypes_SqlBytes ()
1153                 {
1154                         SqlParameter parameter;
1155                         SqlBytes value = new SqlBytes (new byte [] { 0x0d, 0x0a });
1156
1157                         parameter = new SqlParameter ();
1158                         parameter.SqlValue = value;
1159                         Assert.AreEqual (SqlDbType.VarBinary, parameter.SqlDbType, "#A:SqlDbType");
1160                         Assert.AreSame (value, parameter.SqlValue, "#A:SqlValue");
1161                         Assert.AreSame (value, parameter.Value, "#A:Value");
1162
1163                         parameter = new SqlParameter ();
1164                         parameter.SqlValue = SqlBytes.Null;
1165                         Assert.AreEqual (SqlDbType.VarBinary, parameter.SqlDbType, "#B:SqlDbType");
1166                         Assert.IsNotNull (parameter.SqlValue, "#B:SqlValue1");
1167                         Assert.AreEqual (typeof (SqlBytes), parameter.SqlValue.GetType (), "#B:SqlValue2");
1168                         Assert.IsTrue (((SqlBytes) parameter.SqlValue).IsNull, "#B:SqlValue3");
1169                         Assert.IsNotNull (parameter.Value, "#B:Value1");
1170                         Assert.AreEqual (typeof (SqlBytes), parameter.Value.GetType (), "#B:Value2");
1171                         Assert.IsTrue (((SqlBytes) parameter.Value).IsNull, "#B:Value3");
1172
1173                         parameter = new SqlParameter ();
1174                         parameter.Value = value;
1175                         Assert.AreEqual (SqlDbType.VarBinary, parameter.SqlDbType, "#C:SqlDbType");
1176                         Assert.AreEqual (value, parameter.SqlValue, "#C:SqlValue");
1177                         Assert.AreEqual (value, parameter.Value, "#C:Value");
1178                 }
1179
1180                 [Test]
1181                 [Category ("NotWorking")]
1182                 // This doesn't work as SqlChars are represented as SqlString
1183                 public void SqlTypes_SqlChars ()
1184                 {
1185                         SqlParameter parameter;
1186                         SqlChars value = new SqlChars (new char [] { 'X', 'A' });
1187
1188                         parameter = new SqlParameter ();
1189                         parameter.SqlValue = value;
1190                         Assert.AreEqual (SqlDbType.NVarChar, parameter.SqlDbType, "#A:SqlDbType");
1191                         Assert.AreSame (value, parameter.SqlValue, "#A:SqlValue");
1192                         Assert.AreSame (value, parameter.Value, "#A:Value");
1193
1194                         parameter = new SqlParameter ();
1195                         parameter.SqlValue = SqlChars.Null;
1196                         Assert.AreEqual (SqlDbType.NVarChar, parameter.SqlDbType, "#B:SqlDbType");
1197                         Assert.IsNotNull (parameter.SqlValue, "#B:SqlValue1");
1198                         Assert.AreEqual (typeof (SqlChars), parameter.SqlValue.GetType (), "#B:SqlValue2");
1199                         Assert.IsTrue (((SqlChars) parameter.SqlValue).IsNull, "#B:SqlValue3");
1200                         Assert.IsNotNull (parameter.Value, "#B:Value1");
1201                         Assert.AreEqual (typeof (SqlChars), parameter.Value.GetType (), "#B:Value2");
1202                         Assert.IsTrue (((SqlChars) parameter.Value).IsNull, "#B:Value3");
1203
1204                         parameter = new SqlParameter ();
1205                         parameter.Value = value;
1206                         Assert.AreEqual (SqlDbType.NVarChar, parameter.SqlDbType, "#C:SqlDbType");
1207                         Assert.AreSame (value, parameter.SqlValue, "#C:SqlValue");
1208                         Assert.AreSame (value, parameter.Value, "#C:Value");
1209                 }
1210
1211                 [Test]
1212 #if FEATURE_NO_BSD_SOCKETS
1213                 [ExpectedException (typeof (PlatformNotSupportedException))]
1214 #endif
1215                 public void SqlTypes_SqlDateTime ()
1216                 {
1217                         SqlParameter parameter;
1218                         SqlDateTime value = new SqlDateTime (DateTime.Now);
1219
1220                         parameter = new SqlParameter ();
1221                         parameter.SqlValue = value;
1222                         Assert.AreEqual (SqlDbType.DateTime, parameter.SqlDbType, "#A:SqlDbType");
1223                         Assert.AreEqual (value, parameter.SqlValue, "#A:SqlValue");
1224                         Assert.AreEqual (value, parameter.Value, "#A:Value");
1225
1226                         parameter = new SqlParameter ();
1227                         parameter.SqlValue = SqlDateTime.Null;
1228                         Assert.AreEqual (SqlDbType.DateTime, parameter.SqlDbType, "#B:SqlDbType");
1229                         Assert.AreEqual (SqlDateTime.Null, parameter.SqlValue, "#B:SqlValue");
1230                         Assert.AreEqual (SqlDateTime.Null, parameter.Value, "#B:Value");
1231
1232                         parameter = new SqlParameter ();
1233                         parameter.Value = value;
1234                         Assert.AreEqual (SqlDbType.DateTime, parameter.SqlDbType, "#C:SqlDbType");
1235                         Assert.AreEqual (value, parameter.SqlValue, "#C:SqlValue");
1236                         Assert.AreEqual (value, parameter.Value, "#C:Value");
1237                 }
1238
1239                 [Test]
1240 #if FEATURE_NO_BSD_SOCKETS
1241                 [ExpectedException (typeof (PlatformNotSupportedException))]
1242 #endif
1243                 public void SqlTypes_SqlDecimal ()
1244                 {
1245                         SqlParameter parameter;
1246                         SqlDecimal value = new SqlDecimal (45m);
1247
1248                         parameter = new SqlParameter ();
1249                         parameter.SqlValue = value;
1250                         Assert.AreEqual (SqlDbType.Decimal, parameter.SqlDbType, "#A:SqlDbType");
1251                         Assert.AreEqual (value, parameter.SqlValue, "#A:SqlValue");
1252                         Assert.AreEqual (value, parameter.Value, "#A:Value");
1253
1254                         parameter = new SqlParameter ();
1255                         parameter.SqlValue = SqlDecimal.Null;
1256                         Assert.AreEqual (SqlDbType.Decimal, parameter.SqlDbType, "#B:SqlDbType");
1257                         Assert.AreEqual (SqlDecimal.Null, parameter.SqlValue, "#B:SqlValue");
1258                         Assert.AreEqual (SqlDecimal.Null, parameter.Value, "#B:Value");
1259
1260                         parameter = new SqlParameter ();
1261                         parameter.Value = value;
1262                         Assert.AreEqual (SqlDbType.Decimal, parameter.SqlDbType, "#C:SqlDbType");
1263                         Assert.AreEqual (value, parameter.SqlValue, "#C:SqlValue");
1264                         Assert.AreEqual (value, parameter.Value, "#C:Value");
1265                 }
1266
1267                 [Test]
1268 #if FEATURE_NO_BSD_SOCKETS
1269                 [ExpectedException (typeof (PlatformNotSupportedException))]
1270 #endif
1271                 public void SqlTypes_SqlDouble ()
1272                 {
1273                         SqlParameter parameter;
1274                         SqlDouble value = new SqlDouble (4.5D);
1275
1276                         parameter = new SqlParameter ();
1277                         parameter.SqlValue = value;
1278                         Assert.AreEqual (SqlDbType.Float, parameter.SqlDbType, "#A:SqlDbType");
1279                         Assert.AreEqual (value, parameter.SqlValue, "#A:SqlValue");
1280                         Assert.AreEqual (value, parameter.Value, "#A:Value");
1281
1282                         parameter = new SqlParameter ();
1283                         parameter.SqlValue = SqlDouble.Null;
1284                         Assert.AreEqual (SqlDbType.Float, parameter.SqlDbType, "#B:SqlDbType");
1285                         Assert.AreEqual (SqlDouble.Null, parameter.SqlValue, "#B:SqlValue");
1286                         Assert.AreEqual (SqlDouble.Null, parameter.Value, "#B:Value");
1287
1288                         parameter = new SqlParameter ();
1289                         parameter.Value = value;
1290                         Assert.AreEqual (SqlDbType.Float, parameter.SqlDbType, "#C:SqlDbType");
1291                         Assert.AreEqual (value, parameter.SqlValue, "#C:SqlValue");
1292                         Assert.AreEqual (value, parameter.Value, "#C:Value");
1293                 }
1294
1295                 [Test]
1296 #if FEATURE_NO_BSD_SOCKETS
1297                 [ExpectedException (typeof (PlatformNotSupportedException))]
1298 #endif
1299                 public void SqlTypes_SqlGuid ()
1300                 {
1301                         SqlParameter parameter;
1302                         SqlGuid value = new SqlGuid (Guid.NewGuid ());
1303
1304                         parameter = new SqlParameter ();
1305                         parameter.SqlValue = value;
1306                         Assert.AreEqual (SqlDbType.UniqueIdentifier, parameter.SqlDbType, "#A:SqlDbType");
1307                         Assert.AreEqual (value, parameter.SqlValue, "#A:SqlValue");
1308                         Assert.AreEqual (value, parameter.Value, "#A:Value");
1309
1310                         parameter = new SqlParameter ();
1311                         parameter.SqlValue = SqlGuid.Null;
1312                         Assert.AreEqual (SqlDbType.UniqueIdentifier, parameter.SqlDbType, "#B:SqlDbType");
1313                         Assert.AreEqual (SqlGuid.Null, parameter.SqlValue, "#B:SqlValue");
1314                         Assert.AreEqual (SqlGuid.Null, parameter.Value, "#B:Value");
1315
1316                         parameter = new SqlParameter ();
1317                         parameter.Value = value;
1318                         Assert.AreEqual (SqlDbType.UniqueIdentifier, parameter.SqlDbType, "#C:SqlDbType");
1319                         Assert.AreEqual (value, parameter.SqlValue, "#C:SqlValue");
1320                         Assert.AreEqual (value, parameter.Value, "#C:Value");
1321                 }
1322
1323                 [Test]
1324 #if FEATURE_NO_BSD_SOCKETS
1325                 [ExpectedException (typeof (PlatformNotSupportedException))]
1326 #endif
1327                 public void SqlTypes_SqlInt16 ()
1328                 {
1329                         SqlParameter parameter;
1330                         SqlInt16 value = new SqlInt16 ((short) 5);
1331
1332                         parameter = new SqlParameter ();
1333                         parameter.SqlValue = value;
1334                         Assert.AreEqual (SqlDbType.SmallInt, parameter.SqlDbType, "#A:SqlDbType");
1335                         Assert.AreEqual (value, parameter.SqlValue, "#A:SqlValue");
1336                         Assert.AreEqual (value, parameter.Value, "#A:Value");
1337
1338                         parameter = new SqlParameter ();
1339                         parameter.SqlValue = SqlInt16.Null;
1340                         Assert.AreEqual (SqlDbType.SmallInt, parameter.SqlDbType, "#B:SqlDbType");
1341                         Assert.AreEqual (SqlInt16.Null, parameter.SqlValue, "#B:SqlValue");
1342                         Assert.AreEqual (SqlInt16.Null, parameter.Value, "#B:Value");
1343
1344                         parameter = new SqlParameter ();
1345                         parameter.Value = value;
1346                         Assert.AreEqual (SqlDbType.SmallInt, parameter.SqlDbType, "#C:SqlDbType");
1347                         Assert.AreEqual (value, parameter.SqlValue, "#C:SqlValue");
1348                         Assert.AreEqual (value, parameter.Value, "#C:Value");
1349                 }
1350
1351                 [Test]
1352 #if FEATURE_NO_BSD_SOCKETS
1353                 [ExpectedException (typeof (PlatformNotSupportedException))]
1354 #endif
1355                 public void SqlTypes_SqlInt32 ()
1356                 {
1357                         SqlParameter parameter;
1358                         SqlInt32 value = new SqlInt32 (5);
1359
1360                         parameter = new SqlParameter ();
1361                         parameter.SqlValue = value;
1362                         Assert.AreEqual (SqlDbType.Int, parameter.SqlDbType, "#A:SqlDbType");
1363                         Assert.AreEqual (value, parameter.SqlValue, "#A:SqlValue");
1364                         Assert.AreEqual (value, parameter.Value, "#A:Value");
1365
1366                         parameter = new SqlParameter ();
1367                         parameter.SqlValue = SqlInt32.Null;
1368                         Assert.AreEqual (SqlDbType.Int, parameter.SqlDbType, "#B:SqlDbType");
1369                         Assert.AreEqual (SqlInt32.Null, parameter.SqlValue, "#B:SqlValue");
1370                         Assert.AreEqual (SqlInt32.Null, parameter.Value, "#B:Value");
1371
1372                         parameter = new SqlParameter ();
1373                         parameter.Value = value;
1374                         Assert.AreEqual (SqlDbType.Int, parameter.SqlDbType, "#C:SqlDbType");
1375                         Assert.AreEqual (value, parameter.SqlValue, "#C:SqlValue");
1376                         Assert.AreEqual (value, parameter.Value, "#C:Value");
1377                 }
1378
1379                 [Test]
1380 #if FEATURE_NO_BSD_SOCKETS
1381                 [ExpectedException (typeof (PlatformNotSupportedException))]
1382 #endif
1383                 public void SqlTypes_SqlInt64 ()
1384                 {
1385                         SqlParameter parameter;
1386                         SqlInt64 value = new SqlInt64 (5L);
1387
1388                         parameter = new SqlParameter ();
1389                         parameter.SqlValue = value;
1390                         Assert.AreEqual (SqlDbType.BigInt, parameter.SqlDbType, "#A:SqlDbType");
1391                         Assert.AreEqual (value, parameter.SqlValue, "#A:SqlValue");
1392                         Assert.AreEqual (value, parameter.Value, "#A:Value");
1393
1394                         parameter = new SqlParameter ();
1395                         parameter.SqlValue = SqlInt64.Null;
1396                         Assert.AreEqual (SqlDbType.BigInt, parameter.SqlDbType, "#B:SqlDbType");
1397                         Assert.AreEqual (SqlInt64.Null, parameter.SqlValue, "#B:SqlValue");
1398                         Assert.AreEqual (SqlInt64.Null, parameter.Value, "#B:Value");
1399
1400                         parameter = new SqlParameter ();
1401                         parameter.Value = value;
1402                         Assert.AreEqual (SqlDbType.BigInt, parameter.SqlDbType, "#C:SqlDbType");
1403                         Assert.AreEqual (value, parameter.SqlValue, "#C:SqlValue");
1404                         Assert.AreEqual (value, parameter.Value, "#C:Value");
1405                 }
1406
1407                 [Test]
1408 #if FEATURE_NO_BSD_SOCKETS
1409                 [ExpectedException (typeof (PlatformNotSupportedException))]
1410 #endif
1411                 public void SqlTypes_SqlMoney ()
1412                 {
1413                         SqlParameter parameter;
1414                         SqlMoney value = new SqlMoney (45m);
1415
1416                         parameter = new SqlParameter ();
1417                         parameter.SqlValue = value;
1418                         Assert.AreEqual (SqlDbType.Money, parameter.SqlDbType, "#A:SqlDbType");
1419                         Assert.AreEqual (value, parameter.SqlValue, "#A:SqlValue");
1420                         Assert.AreEqual (value, parameter.Value, "#A:Value");
1421
1422                         parameter = new SqlParameter ();
1423                         parameter.SqlValue = SqlMoney.Null;
1424                         Assert.AreEqual (SqlDbType.Money, parameter.SqlDbType, "#B:SqlDbType");
1425                         Assert.AreEqual (SqlMoney.Null, parameter.SqlValue, "#B:SqlValue");
1426                         Assert.AreEqual (SqlMoney.Null, parameter.Value, "#B:Value");
1427
1428                         parameter = new SqlParameter ();
1429                         parameter.Value = value;
1430                         Assert.AreEqual (SqlDbType.Money, parameter.SqlDbType, "#C:SqlDbType");
1431                         Assert.AreEqual (value, parameter.SqlValue, "#C:SqlValue");
1432                         Assert.AreEqual (value, parameter.Value, "#C:Value");
1433                 }
1434
1435                 [Test]
1436 #if FEATURE_NO_BSD_SOCKETS
1437                 [ExpectedException (typeof (PlatformNotSupportedException))]
1438 #endif
1439                 public void SqlTypes_SqlSingle ()
1440                 {
1441                         SqlParameter parameter;
1442                         SqlSingle value = new SqlSingle (45f);
1443
1444                         parameter = new SqlParameter ();
1445                         parameter.SqlValue = value;
1446                         Assert.AreEqual (SqlDbType.Real, parameter.SqlDbType, "#A:SqlDbType");
1447                         Assert.AreEqual (value, parameter.SqlValue, "#A:SqlValue");
1448                         Assert.AreEqual (value, parameter.Value, "#A:Value");
1449
1450                         parameter = new SqlParameter ();
1451                         parameter.SqlValue = SqlSingle.Null;
1452                         Assert.AreEqual (SqlDbType.Real, parameter.SqlDbType, "#B:SqlDbType");
1453                         Assert.AreEqual (SqlSingle.Null, parameter.SqlValue, "#B:SqlValue");
1454                         Assert.AreEqual (SqlSingle.Null, parameter.Value, "#B:Value");
1455
1456                         parameter = new SqlParameter ();
1457                         parameter.Value = value;
1458                         Assert.AreEqual (SqlDbType.Real, parameter.SqlDbType, "#C:SqlDbType");
1459                         Assert.AreEqual (value, parameter.SqlValue, "#C:SqlValue");
1460                         Assert.AreEqual (value, parameter.Value, "#C:Value");
1461                 }
1462
1463                 [Test]
1464 #if FEATURE_NO_BSD_SOCKETS
1465                 [ExpectedException (typeof (PlatformNotSupportedException))]
1466 #endif
1467                 public void SqlTypes_SqlString ()
1468                 {
1469                         SqlParameter parameter;
1470                         SqlString value = new SqlString ("XA");
1471
1472                         parameter = new SqlParameter ();
1473                         parameter.SqlValue = value;
1474                         Assert.AreEqual (SqlDbType.NVarChar, parameter.SqlDbType, "#A:SqlDbType");
1475                         Assert.AreEqual (value, parameter.SqlValue, "#A:SqlValue");
1476                         Assert.AreEqual (value, parameter.Value, "#A:Value");
1477
1478                         parameter = new SqlParameter ();
1479                         parameter.SqlValue = SqlString.Null;
1480                         Assert.AreEqual (SqlDbType.NVarChar, parameter.SqlDbType, "#B:SqlDbType");
1481                         Assert.AreEqual (SqlString.Null, parameter.SqlValue, "#B:SqlValue");
1482                         Assert.AreEqual (SqlString.Null, parameter.Value, "#B:Value");
1483
1484                         parameter = new SqlParameter ();
1485                         parameter.Value = value;
1486                         Assert.AreEqual (SqlDbType.NVarChar, parameter.SqlDbType, "#C:SqlDbType");
1487                         Assert.AreEqual (value, parameter.SqlValue, "#C:SqlValue");
1488                         Assert.AreEqual (value, parameter.Value, "#C:Value");
1489                 }
1490
1491                 [Test]
1492 #if FEATURE_NO_BSD_SOCKETS
1493                 [ExpectedException (typeof (PlatformNotSupportedException))]
1494 #endif
1495                 public void SqlTypes_SqlXml ()
1496                 {
1497                         SqlParameter parameter;
1498                         SqlXml value = new SqlXml (new XmlTextReader (new StringReader ("<test>Mono</test>")));
1499
1500                         parameter = new SqlParameter ();
1501                         parameter.SqlValue = value;
1502                         Assert.AreEqual (SqlDbType.Xml, parameter.SqlDbType, "#A:SqlDbType");
1503                         Assert.AreSame (value, parameter.SqlValue, "#A:SqlValue");
1504                         Assert.AreSame (value, parameter.Value, "#A:Value");
1505
1506                         parameter = new SqlParameter ();
1507                         parameter.SqlValue = SqlXml.Null;
1508                         Assert.AreEqual (SqlDbType.Xml, parameter.SqlDbType, "#B:SqlDbType");
1509                         Assert.IsNotNull (parameter.SqlValue, "#B:SqlValue1");
1510                         Assert.AreEqual (typeof (SqlXml), parameter.SqlValue.GetType (), "#B:SqlValue2");
1511                         Assert.IsTrue (((SqlXml) parameter.SqlValue).IsNull, "#B:SqlValue3");
1512                         Assert.IsNotNull (parameter.Value, "#B:Value1");
1513                         Assert.AreEqual (typeof (SqlXml), parameter.Value.GetType (), "#B:Value2");
1514                         Assert.IsTrue (((SqlXml) parameter.Value).IsNull, "#B:Value3");
1515
1516                         parameter = new SqlParameter ();
1517                         parameter.Value = value;
1518                         Assert.AreEqual (SqlDbType.Xml, parameter.SqlDbType, "#C:SqlDbType");
1519                         Assert.AreSame (value, parameter.SqlValue, "#C:SqlValue");
1520                         Assert.AreSame (value, parameter.Value, "#C:Value");
1521                 }
1522
1523                 [Test]
1524 #if FEATURE_NO_BSD_SOCKETS
1525                 [ExpectedException (typeof (PlatformNotSupportedException))]
1526 #endif
1527                 public void Value ()
1528                 {
1529                         SqlParameter p;
1530
1531                         p = new SqlParameter ("name", (Object) null);
1532                         p.Value = 42;
1533                         Assert.AreEqual (DbType.Int32, p.DbType, "#A:DbType");
1534                         Assert.AreEqual (SqlDbType.Int, p.SqlDbType, "#A:SqlDbType");
1535                         Assert.AreEqual (42, p.Value, "#A:Value");
1536
1537                         p.Value = DBNull.Value;
1538                         Assert.AreEqual (DbType.String, p.DbType, "#B:DbType");
1539                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#B:SqlDbType");
1540                         Assert.AreEqual (DBNull.Value, p.Value, "#B:Value");
1541
1542                         p.Value = DateTime.MaxValue;
1543                         Assert.AreEqual (DbType.DateTime, p.DbType, "#C:DbType");
1544                         Assert.AreEqual (SqlDbType.DateTime, p.SqlDbType, "#C:SqlDbType");
1545                         Assert.AreEqual (DateTime.MaxValue, p.Value, "#C:Value");
1546
1547                         p.Value = null;
1548                         Assert.AreEqual (DbType.String, p.DbType, "#D:DbType");
1549                         Assert.AreEqual (SqlDbType.NVarChar, p.SqlDbType, "#D:SqlDbType");
1550                         Assert.IsNull (p.Value, "#D:Value");
1551
1552                         p = new SqlParameter ("zipcode", SqlDbType.Int);
1553                         p.Value = DateTime.MaxValue;
1554                         Assert.AreEqual (DbType.Int32, p.DbType, "#E:DbType");
1555                         Assert.AreEqual (SqlDbType.Int, p.SqlDbType, "#E:SqlDbType");
1556                         Assert.AreEqual (DateTime.MaxValue, p.Value, "#E:Value");
1557
1558                         p.Value = null;
1559                         Assert.AreEqual (DbType.Int32, p.DbType, "#F:DbType");
1560                         Assert.AreEqual (SqlDbType.Int, p.SqlDbType, "#F:SqlDbType");
1561                         Assert.IsNull (p.Value, "#F:Value");
1562
1563                         p.Value = DBNull.Value;
1564                         Assert.AreEqual (DbType.Int32, p.DbType, "#G:DbType");
1565                         Assert.AreEqual (SqlDbType.Int, p.SqlDbType, "#G:SqlDbType");
1566                         Assert.AreEqual (DBNull.Value, p.Value, "#G:Value");
1567                 }
1568
1569                 [Test]
1570 #if FEATURE_NO_BSD_SOCKETS
1571                 [ExpectedException (typeof (PlatformNotSupportedException))]
1572 #endif
1573                 public void XmlSchemaTest ()
1574                 {
1575                         SqlParameter p1 = new SqlParameter ();
1576
1577                         //Testing default values
1578                         Assert.AreEqual (String.Empty, p1.XmlSchemaCollectionDatabase,
1579                                          "#1 Default value for XmlSchemaCollectionDatabase is an empty string");
1580                         Assert.AreEqual (String.Empty, p1.XmlSchemaCollectionName,
1581                                          "#2 Default value for XmlSchemaCollectionName is an empty string");
1582                         Assert.AreEqual (String.Empty, p1.XmlSchemaCollectionOwningSchema,
1583                                          "#3 Default value for XmlSchemaCollectionOwningSchema is an empty string");
1584
1585                         //Changing one property should not affect the remaining two properties
1586                         p1.XmlSchemaCollectionDatabase = "database";
1587                         Assert.AreEqual ("database", p1.XmlSchemaCollectionDatabase,
1588                                          "#4 Default value for XmlSchemaCollectionDatabase is an empty string");
1589                         Assert.AreEqual (String.Empty, p1.XmlSchemaCollectionName,
1590                                          "#5 Default value for XmlSchemaCollectionName is an empty string");
1591                         Assert.AreEqual (String.Empty, p1.XmlSchemaCollectionOwningSchema,
1592                                          "#6 Default value for XmlSchemaCollectionOwningSchema is an empty string");
1593
1594                         p1.XmlSchemaCollectionName = "name";
1595                         Assert.AreEqual ("database", p1.XmlSchemaCollectionDatabase,
1596                                          "#7 Default value for XmlSchemaCollectionDatabase is an empty string");
1597                         Assert.AreEqual ("name", p1.XmlSchemaCollectionName,
1598                                          "#8 Default value for XmlSchemaCollectionName is an empty string");
1599                         Assert.AreEqual (String.Empty, p1.XmlSchemaCollectionOwningSchema,
1600                                          "#9 Default value for XmlSchemaCollectionOwningSchema is an empty string");
1601
1602                         p1.XmlSchemaCollectionOwningSchema = "schema";
1603                         Assert.AreEqual ("database", p1.XmlSchemaCollectionDatabase,
1604                                          "#10 Default value for XmlSchemaCollectionDatabase is an empty string");
1605                         Assert.AreEqual ("name", p1.XmlSchemaCollectionName,
1606                                          "#11 Default value for XmlSchemaCollectionName is an empty string");
1607                         Assert.AreEqual ("schema", p1.XmlSchemaCollectionOwningSchema,
1608                                          "#12 Default value for XmlSchemaCollectionOwningSchema is an empty string");
1609
1610                         //assigning null value stores default empty string
1611                         p1.XmlSchemaCollectionDatabase = null;
1612                         Assert.AreEqual (String.Empty, p1.XmlSchemaCollectionDatabase,
1613                                          "#13 Default value for XmlSchemaCollectionDatabase is an empty string");
1614                         Assert.AreEqual ("name", p1.XmlSchemaCollectionName,
1615                                          "#14 Default value for XmlSchemaCollectionName is an empty string");
1616                         Assert.AreEqual ("schema", p1.XmlSchemaCollectionOwningSchema,
1617                                          "#15 Default value for XmlSchemaCollectionOwningSchema is an empty string");
1618
1619                         p1.XmlSchemaCollectionName = "";
1620                         Assert.AreEqual (String.Empty, p1.XmlSchemaCollectionDatabase,
1621                                          "#16 Default value for XmlSchemaCollectionDatabase is an empty string");
1622                         Assert.AreEqual ("", p1.XmlSchemaCollectionName,
1623                                          "#17 Default value for XmlSchemaCollectionName is an empty string");
1624                         Assert.AreEqual ("schema", p1.XmlSchemaCollectionOwningSchema,
1625                                          "#18 Default value for XmlSchemaCollectionOwningSchema is an empty string");
1626
1627                         //values are not trimmed
1628                         p1.XmlSchemaCollectionOwningSchema = "  a  ";
1629                         Assert.AreEqual (String.Empty, p1.XmlSchemaCollectionDatabase,
1630                                          "#19 Default value for XmlSchemaCollectionDatabase is an empty string");
1631                         Assert.AreEqual ("", p1.XmlSchemaCollectionName,
1632                                          "#20 Default value for XmlSchemaCollectionName is an empty string");
1633                         Assert.AreEqual ("  a  ", p1.XmlSchemaCollectionOwningSchema,
1634                                          "#21 Default value for XmlSchemaCollectionOwningSchema is an empty string");
1635                 }
1636
1637                 private enum ByteEnum : byte
1638                 {
1639                         A = 0x0a,
1640                         B = 0x0d
1641                 }
1642
1643                 private enum Int64Enum : long
1644                 {
1645                         A = long.MinValue,
1646                         B = long.MaxValue
1647                 }
1648         }
1649 }