mcs/class/System.Data/Test/ProviderTests/System.Data.Odbc/OdbcParameterCollectionTest.cs

   1 //
   2 // OdbcParameterCollectionTest.cs - NUnit Test Cases for testing the
   3 //                        OdbcParameterCollection class
   4 // Author:
   5 //      Sureshkumar T (TSureshkumar@novell.com)
   6 //      Amit Biswas (amit@amitbiswas.com)
   7 //
   8 // Copyright (c) 2004 Novell Inc., and the individuals listed
   9 // on the ChangeLog entries.
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30
  31 #if !NO_ODBC
  32
  33 using System;
  34 using System.Text;
  35 using System.Data;
  36 using System.Data.Odbc;
  37
  38 using NUnit.Framework;
  39
  40 namespace MonoTests.System.Data.Connected.Odbc
  41 {
  42         [TestFixture]
  43         [Category ("odbc")]
  44         public class OdbcParameterCollectionTest
  45         {
  46                 /// <remarks>
  47                 /// This tests whether the value is trimmed to the
  48                 /// given length while passing parameters
  49                 /// </remarks>
  50                 [Test]
  51                 public void ParameterLengthTrimTest ()
  52                 {
  53                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
  54
  55                         try {
  56                                 OdbcCommand cmd = conn.CreateCommand ();
  57                                 cmd.CommandType = CommandType.Text;
  58                                 cmd.CommandText = "SELECT count(*) FROM employee WHERE fname=?";
  59
  60                                 OdbcParameter param = cmd.Parameters.Add("@fname", OdbcType.VarChar, 15);
  61                                 param.Value = DateTime.Now.ToString ();
  62                                 Assert.AreEqual (15, param.Size, "#1");
  63                                 Assert.AreEqual (0, cmd.ExecuteScalar(), "#2");
  64                         } finally {
  65                                 ConnectionManager.Instance.Odbc.CloseConnection ();
  66                         }
  67                 }
  68
  69                 [Test]
  70                 public void InsertTest ()
  71                 {
  72                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
  73
  74                         try {
  75                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
  76                                 OdbcCmd.CommandType = CommandType.Text;
  77                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
  78
  79                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
  80                                 OdbcParameter p2Age = new OdbcParameter (); //not initialized and not yet added
  81                                 OdbcParameter p3Tmp = new OdbcParameter ("p3", "abc"); //not added
  82
  83                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
  84                                 OdbcCmd.Parameters.Insert (1, p2Age); //Inserting the second parameter
  85                                 Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#2 The collection should contain 2 parameters");
  86
  87                                 //inserting at upper boundary
  88                                 OdbcCmd.Parameters.Insert (OdbcCmd.Parameters.Count, p3Tmp); //Inserting the third parameter, with name and value at index = count
  89                                 Assert.AreEqual (3, OdbcCmd.Parameters.Count, "#3 The collection should contain 2 parameters");
  90
  91                                 //check the inserted positions
  92                                 Assert.AreEqual (0, OdbcCmd.Parameters.IndexOf ("@lname"), "#4 The first parameter must be at index 0");
  93                                 Assert.AreEqual (1, OdbcCmd.Parameters.IndexOf (p2Age), "#5 The inserted parameter p2Age must be at index 1");
  94                                 Assert.AreEqual (2, OdbcCmd.Parameters.IndexOf (p3Tmp), "#6 The inserted parameter p3Tmp must be at index 2");
  95                                 Assert.AreEqual (2, OdbcCmd.Parameters.IndexOf ("p3"), "#7 The inserted parameter p3 must be at index 2");
  96                                 Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf ("non-existing-parameter"), "#8 Non-existing parameters should return -1");
  97
  98                                 //check for default names and default values
  99                                 Assert.AreEqual ("Parameter1", OdbcCmd.Parameters[1].ParameterName, "#9 Parameters inserted without any name must get a default name");
 100                                 Assert.AreEqual (null, OdbcCmd.Parameters[1].Value, "#10 Parameters inserted without any value must have null value");
 101
 102                                 Assert.AreEqual ("p3", OdbcCmd.Parameters[2].ParameterName, "#11 Parameters inserted without any name must get a default name");
 103                                 Assert.AreEqual ("abc", OdbcCmd.Parameters[2].Value, "#12 Parameters inserted without any value must have null value");
 104
 105                                 Assert.AreEqual (OdbcType.NVarChar,OdbcCmd.Parameters[1].OdbcType, "#13 Parameters with null value must be of type NVarChar");
 106                                 Assert.AreEqual (OdbcType.Text,OdbcCmd.Parameters[0].OdbcType, "#14 Parameter at index 0 is of type Text");
 107                         } finally {
 108                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 109                         }
 110                 }
 111
 112                 /// <remarks>
 113                 /// Inserting parameters in between the collection should not
 114                 /// overwrite the existing parameters
 115                 /// </remarks>
 116                 [Test]
 117                 public void InsertNoOverwriteTest ()
 118                 {
 119                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 120
 121                         try {
 122                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 123                                 OdbcCmd.CommandType = CommandType.Text;
 124                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 125
 126                                 OdbcParameter p1Lname = OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 127                                 OdbcParameter p2Age = OdbcCmd.Parameters.Add ("@age", OdbcType.Int, 2);
 128                                 OdbcParameter p3Tmp = OdbcCmd.Parameters.Add ("@Tmp", OdbcType.Text, 15);
 129                                 OdbcParameter p4Tmp = new OdbcParameter ();
 130
 131                                 Assert.AreEqual (3, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 132                                 OdbcCmd.Parameters.Insert (1, p4Tmp); //Inserting at index 1
 133                                 Assert.AreEqual (4, OdbcCmd.Parameters.Count, "#2 Collection should contain 4 parameters");
 134
 135                                 //Existing parameters should not be overwritten
 136                                 Assert.AreEqual (0, OdbcCmd.Parameters.IndexOf (p1Lname), "#3 The parameter at index 0 should not change");
 137                                 Assert.AreEqual (1, OdbcCmd.Parameters.IndexOf (p4Tmp), "#4 The inserted parameter should be at index 1");
 138                                 Assert.AreEqual (2, OdbcCmd.Parameters.IndexOf (p2Age), "#5 The parameter at index 1 should be at index 2 after inserting");
 139                                 Assert.AreEqual (3, OdbcCmd.Parameters.IndexOf (p3Tmp), "#6 The parameter at index 2 should be at index 3 after inserting");
 140                                 Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf ("non-existing-parameter"), "#7 Non-existing parameters should return -1");
 141
 142                                 //check for default names and default values
 143                                 Assert.AreEqual ("Parameter1", OdbcCmd.Parameters[1].ParameterName, "#8 Parameters inserted without any name must get a default name");
 144                                 Assert.AreEqual (null, OdbcCmd.Parameters[1].Value, "#9 Parameters inserted without any value must have null value");
 145                         } finally {
 146                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 147                         }
 148                 }
 149
 150                 [Test]
 151                 public void InsertNullTest ()
 152                 {
 153                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 154
 155                         try {
 156                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 157                                 OdbcCmd.CommandType = CommandType.Text;
 158                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 159
 160                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 161
 162                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 163                                 try {
 164                                         OdbcCmd.Parameters.Insert (1, null);
 165                                         Assert.Fail ("Expected exception ArgumentNullException was not thrown");
 166                                 } catch (ArgumentNullException) {
 167                                         Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#2 The collection must contain only one parameter after Insert failed");
 168                                 }
 169                         } finally {
 170                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 171                         }
 172                 }
 173
 174                 [Test]
 175                 public void InsertEmptyTest ()
 176                 {
 177                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 178
 179                         try {
 180                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 181                                 OdbcCmd.CommandType = CommandType.Text;
 182                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 183
 184                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 185
 186                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 187                                 try {
 188                                         OdbcCmd.Parameters.Insert (1, string.Empty);
 189                                         Assert.Fail ("Expected exception InvalidCastException was not thrown");
 190                                 } catch (InvalidCastException) {
 191                                         Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#2 The collection must contain only one parameter after Insert failed");
 192                                 }
 193
 194                         } finally {
 195                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 196                         }
 197                 }
 198
 199                 [Test]
 200                 public void InsertAlreadyContainedParameterTest ()
 201                 {
 202                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 203
 204                         try {
 205                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 206                                 OdbcCmd.CommandType = CommandType.Text;
 207                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 208
 209                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 210                                 OdbcParameter p2Age = new OdbcParameter (); //not initialized and not yet added
 211
 212                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 213                                 OdbcCmd.Parameters.Insert (1, p2Age);
 214                                 Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#2 The collection must contain 2 parameters");
 215                                 try {
 216                                         OdbcCmd.Parameters.Insert (2, p2Age); //p2Age is already contained
 217                                         Assert.Fail ("Expected exception ArgumentException not thrown");
 218                                 } catch (ArgumentException) {
 219                                         Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#3 The collection must contain 2 parameters after Insert failed");
 220                                 }
 221                         } finally {
 222                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 223                         }
 224                 }
 225
 226                 [Test]
 227                 public void InsertArgumentGreaterThanCountTest ()
 228                 {
 229                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 230
 231                         try {
 232                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 233                                 OdbcCmd.CommandType = CommandType.Text;
 234                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 235                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 236                                 OdbcParameter p2Age = new OdbcParameter ();
 237
 238                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 239                                 try {
 240                                         OdbcCmd.Parameters.Insert (OdbcCmd.Parameters.Count + 1, p2Age); //Inserting with wrong index
 241                                         Assert.Fail ("Expected Exception ArgumentOutOfRangeException not thrown");
 242                                 } catch (ArgumentOutOfRangeException) {
 243                                         Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#2 The collection must contain only 1 parameter after Insert failed");
 244                                 }
 245                         } finally {
 246                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 247                         }
 248                 }
 249
 250                 [Test]
 251                 public void InsertNegativeArgumentTest ()
 252                 {
 253                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 254
 255                         try {
 256                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 257                                 OdbcCmd.CommandType = CommandType.Text;
 258                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 259                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 260                                 OdbcParameter p2Age = new OdbcParameter ();
 261
 262                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 263                                 try {
 264                                         OdbcCmd.Parameters.Insert (-3, p2Age); //Insert with negative index
 265                                         Assert.Fail ("Expected Exception ArgumentOutOfRangeException not thrown");
 266                                 } catch (ArgumentOutOfRangeException) {
 267                                         Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#2 The collection must contain only 1 parameter after Insert failed");
 268                                 }
 269                         } finally {
 270                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 271                         }
 272                 }
 273
 274                 [Test]
 275                 public void InsertNonOdbcParameterTest ()
 276                 {
 277                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 278
 279                         try {
 280                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 281                                 OdbcCmd.CommandType = CommandType.Text;
 282                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 283
 284                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 285
 286                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 287                                 try {
 288                                         OdbcCmd.Parameters.Insert (1, 4);
 289                                         Assert.Fail ("Expected exception InvalidCastException was not thrown");
 290                                 } catch (InvalidCastException) {
 291                                         Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#2 The collection must contain only 1 parameter after Insert failed");
 292                                 }
 293                         } finally {
 294                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 295                         }
 296                 }
 297
 298
 299                 [Test]
 300                 public void AddRangeTest ()
 301                 {
 302                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 303
 304                         try {
 305                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 306                                 OdbcCmd.CommandType = CommandType.Text;
 307                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 308                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 309                                 OdbcParameter p2Age = new OdbcParameter (); //not initialized and not yet added
 310                                 OdbcParameter p3Tmp = new OdbcParameter (); //not initialized and not yet added
 311                                 OdbcParameter p4Tmp = new OdbcParameter (); //not initialized and not yet added
 312                                 OdbcParameter p5Tmp = new OdbcParameter (); //not initialized and not yet added
 313
 314                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 315                                 OdbcParameter [] paramArray = new OdbcParameter [4];
 316                                 paramArray [0] = p2Age;
 317                                 paramArray [1] = p3Tmp;
 318                                 paramArray [2] = p4Tmp;
 319                                 paramArray [3] = p5Tmp;
 320                                 OdbcCmd.Parameters.AddRange (paramArray);
 321                                 Assert.AreEqual (5, OdbcCmd.Parameters.Count, "#2 The array elements are not added");
 322                                 Assert.AreEqual (1, OdbcCmd.Parameters.IndexOf (p2Age), "#3 The first element must be added after the last parameter");
 323                                 Assert.AreEqual (4, OdbcCmd.Parameters.IndexOf (p5Tmp), "#4 Not all elements are added");
 324                                 Assert.AreEqual ("Parameter1", OdbcCmd.Parameters[1].ParameterName, "#5 Parameters added without any name must get a default name");
 325                                 Assert.AreEqual (OdbcType.NVarChar,OdbcCmd.Parameters[1].OdbcType, "#6 Parameters with null value must be of type NVarChar");
 326                         } finally {
 327                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 328                         }
 329                 }
 330
 331                 //<remarks>
 332                 //If a parameter in the range is already contained, all the parameters before it are added and
 333                 //all the parameters after it are rejected
 334                 //</remarks>
 335                 [Test]
 336                 public void AddRangeParameterAlreadyContainedTest ()
 337                 {
 338                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 339
 340                         try {
 341                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 342                                 OdbcCmd.CommandType = CommandType.Text;
 343                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 344                                 OdbcParameter p1Lname = OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 345                                 OdbcParameter p2Age = new OdbcParameter ();
 346                                 OdbcParameter p3Tmp = new OdbcParameter ();
 347
 348                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 349                                 OdbcParameter [] paramArray = new OdbcParameter [3];
 350                                 paramArray [0] = p2Age;
 351                                 paramArray [1] = p1Lname; //p1Lname is already contained
 352                                 paramArray [2] = p3Tmp;
 353                                 try {
 354                                         OdbcCmd.Parameters.AddRange (paramArray);
 355                                         Assert.Fail ("Expected Exception ArgumentException not thrown");
 356                                 } catch (ArgumentException){
 357                                         Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#2 The collection must contain excatly 2 elements after AddRange failed for the third element");
 358                                 }
 359                         } finally {
 360                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 361                         }
 362                 }
 363
 364                 //<remarks>
 365                 //If a parameter in the range is null, all the elements in the range are rejected
 366                 //</remarks>
 367                 [Test]
 368                 public void AddRangeArgumentNullExceptionTest ()
 369                 {
 370                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 371
 372                         try {
 373                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 374                                 OdbcCmd.CommandType = CommandType.Text;
 375                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 376                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 377                                 OdbcParameter p2Age = new OdbcParameter ();
 378                                 OdbcParameter p3Tmp = new OdbcParameter ();
 379
 380                                 OdbcParameter [] paramArray = new OdbcParameter [3];
 381                                 paramArray [0] = p2Age;
 382                                 paramArray [1] = p3Tmp;
 383                                 paramArray [2] = null;
 384                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 385                                 try {
 386                                         OdbcCmd.Parameters.AddRange (paramArray);
 387                                         Assert.Fail ("Expected Exception ArgumentNullException not thrown");
 388                                 } catch (ArgumentNullException){
 389                                         Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#2 If any of the parameters in the range is null, none of them should be added");
 390                                 }
 391                         } finally {
 392                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 393                         }
 394                 }
 395
 396                 [Test]
 397                 public void AddRangeParameterContainedInAnotherCollTest ()
 398                 {
 399                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 400
 401                         try {
 402                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 403                                 OdbcCmd.CommandType = CommandType.Text;
 404                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 405
 406                                 OdbcCommand OdbcCmd2 = conn.CreateCommand ();
 407                                 OdbcCmd2.CommandType = CommandType.Text;
 408                                 OdbcCmd2.CommandText = "SELECT lname FROM employee WHERE fname=? AND age=?";
 409
 410                                 OdbcParameter p1Lname = OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 411                                 OdbcParameter p2Age = new OdbcParameter ();
 412                                 OdbcParameter p3Tmp = new OdbcParameter ();
 413
 414                                 OdbcParameter [] paramArray = new OdbcParameter [3];
 415                                 paramArray [0] = p2Age;
 416                                 paramArray [1] = p1Lname; //p1Lname is already contained in Odbccmd
 417                                 paramArray [2] = p3Tmp;
 418                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the parameter collection of OdbcCmd should contain only 1 parameter");
 419                                 Assert.AreEqual (0, OdbcCmd2.Parameters.Count, "#2 Initialization error, the parameter collection of OdbcCmd2 should not contain any parameters");
 420                                 try {
 421                                         OdbcCmd2.Parameters.AddRange (paramArray);
 422                                         Assert.Fail ("Expected Exception ArgumentException not thrown");
 423                                 } catch (ArgumentException) {
 424                                         Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#3 The parameter collection of OdbcCmd should not change");
 425                                         Assert.AreEqual (1, OdbcCmd2.Parameters.Count, "#4 All the elements before the invalid element must be added to the collection of OdbcCmd2");
 426                                 }
 427                         } finally {
 428                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 429                         }
 430                 }
 431
 432                 [Test]
 433                 public void AddRangeMultiDimensionalArrayTest ()
 434                 {
 435                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 436
 437                         try {
 438                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 439                                 OdbcCmd.CommandType = CommandType.Text;
 440                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 441                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 442                                 OdbcParameter p2Age = new OdbcParameter ();
 443                                 OdbcParameter p3Tmp = new OdbcParameter ();
 444                                 OdbcParameter p4Tmp = new OdbcParameter ();
 445                                 OdbcParameter p5Tmp = new OdbcParameter ();
 446
 447                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 448                                 OdbcParameter [,] paramArray = new OdbcParameter [2, 2];
 449                                 paramArray [0, 0] = p2Age;
 450                                 paramArray [0, 1] = p3Tmp;
 451                                 paramArray [1, 0] = p4Tmp;
 452                                 paramArray [1, 1] = p5Tmp;
 453                                 OdbcCmd.Parameters.AddRange (paramArray);
 454                                 Assert.AreEqual (5, OdbcCmd.Parameters.Count, "#2 Not all four parameters of the 2x2 Array are added");
 455                                 Assert.AreEqual (1, OdbcCmd.Parameters.IndexOf (p2Age), "#3 The first element must be added after the last parameter");
 456                                 Assert.AreEqual (4, OdbcCmd.Parameters.IndexOf (p5Tmp), "#4 Not all elements are added");
 457                                 Assert.AreEqual (OdbcType.NVarChar,OdbcCmd.Parameters[4].OdbcType, "#5 Parameters with null value must be of type NVarChar");
 458                         } finally {
 459                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 460                         }
 461                 }
 462
 463                 [Test]
 464                 public void AddRangeArrayValuesArgumentNullExceptionTest ()
 465                 {
 466                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 467
 468                         try {
 469                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 470                                 OdbcCmd.CommandType = CommandType.Text;
 471                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 472                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 473                                 OdbcParameter p2Age = new OdbcParameter ();
 474                                 OdbcParameter p3Tmp = new OdbcParameter ();
 475                                 OdbcParameter p5Tmp = new OdbcParameter ();
 476
 477                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 478                                 OdbcParameter [,] paramArray = new OdbcParameter [2, 2];
 479                                 paramArray [0, 0] = p2Age;
 480                                 paramArray [0, 1] = p3Tmp;
 481                                 paramArray [1, 0] = null;
 482                                 paramArray [1, 1] = p5Tmp;
 483                                 try {
 484                                         OdbcCmd.Parameters.AddRange (paramArray);
 485                                         Assert.Fail ("Expected Exception ArgumentOutOfRangeException not thrown");
 486                                 } catch (ArgumentNullException) {
 487                                         Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#2 None of the elememts must be added if any one of them is null");
 488                                 }
 489                         } finally {
 490                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 491                         }
 492                 }
 493
 494                 //<remarks>
 495                 //Tests all the three overloads of Contains
 496                 //</remarks>
 497                 [Test]
 498                 public void ContainsTest ()
 499                 {
 500                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 501
 502                         try {
 503                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 504                                 OdbcCmd.CommandType = CommandType.Text;
 505                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 506                                 OdbcParameter p1Lname = OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 507                                 /*OdbcParameter p2Age = */OdbcCmd.Parameters.Add ("@age", OdbcType.Int, 2);
 508                                 OdbcParameter p3Tmp = new OdbcParameter ();
 509                                 OdbcCmd.Parameters.Insert (2, p3Tmp);
 510
 511                                 Assert.AreEqual (3, OdbcCmd.Parameters.Count, "#1 Not all parameters are added");
 512                                 Assert.IsTrue (OdbcCmd.Parameters.Contains (p1Lname), "#2 Contains failed for OdbcParameter value");
 513                                 Assert.IsTrue (OdbcCmd.Parameters.Contains ("@age"), "#3 Contains failed for string value");
 514                                 Assert.IsTrue (OdbcCmd.Parameters.Contains (p3Tmp), "#4 Contains failed for object value");
 515                                 Assert.IsFalse (OdbcCmd.Parameters.Contains (null), "#5 Contains must return false for null value");
 516                                 Assert.IsFalse (OdbcCmd.Parameters.Contains (""), "#6 Contains must return false for empty string");
 517                                 Assert.IsFalse (OdbcCmd.Parameters.Contains ((Object)null), "#6 Contains must return false for empty string");
 518                                 Assert.IsFalse (OdbcCmd.Parameters.Contains ((String)null), "#6 Contains must return false for empty string");
 519                         } finally {
 520                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 521                         }
 522                 }
 523
 524                 [Test]
 525                 public void ContainsNonOdbcParameterTest ()
 526                 {
 527                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 528
 529                         try {
 530                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 531                                 OdbcCmd.CommandType = CommandType.Text;
 532                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 533                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 534
 535                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 The collection must contain only one parameter");
 536                                 try{
 537                                         Assert.IsFalse (OdbcCmd.Parameters.Contains (4), "#2 Contains must return false for non-odbcParameter arguments");
 538                                         Assert.Fail ("Expected Exception InvalidCastException not thrown");
 539                                 } catch (InvalidCastException) {
 540                                         Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#3 The collection must contain only one parameter");
 541                                 }
 542                         } finally {
 543                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 544                         }
 545                 }
 546
 547                 [Test]
 548                 public void ContainsCaseSensitivityTest ()
 549                 {
 550                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 551
 552                         try {
 553                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 554                                 OdbcCmd.CommandType = CommandType.Text;
 555                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 556
 557                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 558
 559                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 560
 561                                 Assert.AreEqual (true, OdbcCmd.Parameters.Contains ("@lname"), "#2 Case sensitivity failed for Contains, should be case insensitive");
 562                                 Assert.AreEqual (true, OdbcCmd.Parameters.Contains ("@LNAME"), "#3 Case sensitivity failed for Contains, should be case insensitive");
 563                                 Assert.AreEqual (true, OdbcCmd.Parameters.Contains ("@LnAmE"), "#4 Case sensitivity failed for Contains, should be case insensitive");
 564                         } finally {
 565                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 566                         }
 567                 }
 568
 569                 [Test]
 570                 public void ContainsNotMineTest ()
 571                 {
 572                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 573
 574                         try {
 575                                 OdbcCommand OdbcCmd1 = conn.CreateCommand ();
 576                                 OdbcCommand OdbcCmd2 = conn.CreateCommand ();
 577                                 OdbcCmd1.CommandType = CommandType.Text;
 578                                 OdbcCmd1.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 579                                 OdbcCmd2.CommandType = CommandType.Text;
 580                                 OdbcCmd2.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 581
 582                                 OdbcParameter p1 = OdbcCmd1.Parameters.Add ("@lname", OdbcType.Text, 15);
 583                                 OdbcParameter p2 = OdbcCmd2.Parameters.Add ("@lname", OdbcType.Text, 15);
 584
 585                                 Assert.IsTrue (OdbcCmd1.Parameters.Contains (p1));
 586                                 Assert.IsFalse (OdbcCmd1.Parameters.Contains (p2));
 587                         } finally {
 588                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 589                         }
 590                 }
 591
 592                 [Test]
 593                 public void IndexOfTest ()
 594                 {
 595                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 596
 597                         try {
 598                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 599                                 OdbcCmd.CommandType = CommandType.Text;
 600                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 601                                 OdbcParameter p1Lname = OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 602                                 OdbcParameter p2Age = OdbcCmd.Parameters.Add ("@age", OdbcType.Int, 2);
 603                                 OdbcParameter p3Tmp = new OdbcParameter ();
 604                                 Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 605
 606                                 Assert.AreEqual (0, OdbcCmd.Parameters.IndexOf (p1Lname), "#1 first parameter not with index 0");
 607                                 Assert.AreEqual (1, OdbcCmd.Parameters.IndexOf (p2Age), "#2 second parameter not with index 1");
 608                                 Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf (p3Tmp), "#3 non-existing parameter should return -1");
 609                                 Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf (null), "#4 null value should return -1");
 610                                 Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf (""), "#5 Empty string parameter should return -1");
 611                                 Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf ((string)null), "#6 Null string parameter should return -1");
 612                                 Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf ("foo"), "#7 non-existing string parameter should return -1");
 613                                 Assert.AreEqual (1, OdbcCmd.Parameters.IndexOf ((Object)p2Age), "#8 second parameter passed as Object did not return index 1");
 614                                 Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf ((Object)p3Tmp), "#9 non-existing parameter passed as Object did not return index -1");
 615                                 Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf ((Object)null), "#10 null parameter passed as Object should return index -1");
 616                         } finally {
 617                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 618                         }
 619                 }
 620
 621                 [Test]
 622                 public void IndexOfCaseSensitivityTest ()
 623                 {
 624                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 625
 626                         try {
 627                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 628                                 OdbcCmd.CommandType = CommandType.Text;
 629                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 630                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 631                                 /*OdbcParameter p2Age = */OdbcCmd.Parameters.Add ("@AGE", OdbcType.Int, 2);
 632                                 Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 633
 634                                 Assert.AreEqual (0, OdbcCmd.Parameters.IndexOf ("@lname"), "#2 Case sensitivity failed for IndexOf, should be case insensitive");
 635                                 Assert.AreEqual (0, OdbcCmd.Parameters.IndexOf ("@LNAME"), "#3 Case sensitivity failed for IndexOf, should be case insensitive");
 636                                 Assert.AreEqual (1, OdbcCmd.Parameters.IndexOf ("@AGE"), "#4 Case sensitivity failed for IndexOf, should be case insensitive");
 637                                 Assert.AreEqual (1, OdbcCmd.Parameters.IndexOf ("@age"), "#5 Case sensitivity failed for IndexOf, should be case insensitive");
 638                         } finally {
 639                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 640                         }
 641                 }
 642
 643                 [Test]
 644                 public void IndexOfNonOdbcParameterTest ()
 645                 {
 646                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 647
 648                         try {
 649                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 650                                 OdbcCmd.CommandType = CommandType.Text;
 651                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 652                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 653
 654                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 The collection must contain only one parameter");
 655                                 try{
 656                                         Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf (4), "#2 IndexOf must return -1 for non-odbcParameter arguments");
 657                                         Assert.Fail ("Expected Exception InvalidCastException not thrown");
 658                                 } catch (InvalidCastException) {
 659                                         Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#3 The collection must contain only one parameter");
 660                                 }
 661                         } finally {
 662                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 663                         }
 664                 }
 665
 666                 [Test]
 667                 public void CopyToTest ()
 668                 {
 669                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 670
 671                         try {
 672                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 673                                 OdbcCmd.CommandType = CommandType.Text;
 674                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 675                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 676                                 /*OdbcParameter p2Age = */OdbcCmd.Parameters.Add ("@age", OdbcType.Int, 2);
 677
 678                                 Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 679                                 OdbcParameter [] DestinationParamArray = new OdbcParameter [4];
 680
 681                                 OdbcCmd.Parameters.CopyTo (DestinationParamArray, 1); //starting at 1 instead of 0
 682
 683                                 Assert.AreEqual (4, DestinationParamArray.Length, "#2 The array length should not change");
 684                                 Assert.AreEqual ("@lname", DestinationParamArray [1].ParameterName, "#3 The first parameter must be copied to array at index 1");
 685                                 Assert.AreEqual ("@age", DestinationParamArray [2].ParameterName, "#4 The second parameter must be copied to array at index 2");
 686                                 Assert.AreEqual (null, DestinationParamArray [0], "#5 The remaining elements must remain un-initialized");
 687                                 Assert.AreEqual (null, DestinationParamArray [3], "#6 The remaining elements must remain un-initialized");
 688                         } finally {
 689                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 690                         }
 691                 }
 692
 693                 [Test]
 694                 public void CopyToArgumentExceptionTest ()
 695                 {
 696                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 697
 698                         try {
 699                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 700                                 OdbcCmd.CommandType = CommandType.Text;
 701                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 702                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 703                                 /*OdbcParameter p2Age = */OdbcCmd.Parameters.Add ("@age", OdbcType.Int, 2);
 704
 705                                 Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 706                                 OdbcParameter [] DestinationParamArray = new OdbcParameter [4];
 707                                 try{
 708                                         OdbcCmd.Parameters.CopyTo (DestinationParamArray, 3); //starting at 3, thus the second element will be at index 4
 709                                         Assert.Fail ("Expected Exception ArgumentException not thrown");
 710                                 } catch (ArgumentException) {
 711                                         Assert.AreEqual (null, DestinationParamArray [0], "#2 The DestinationParamArray must remain un-initialized");
 712                                         Assert.AreEqual (null, DestinationParamArray [1], "#3 The DestinationParamArray must remain un-initialized");
 713                                         Assert.AreEqual (null, DestinationParamArray [2], "#4 The DestinationParamArray must remain un-initialized");
 714                                         Assert.AreEqual (null, DestinationParamArray [3], "#5 The DestinationParamArray must remain un-initialized");
 715                                 }
 716                         } finally {
 717                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 718                         }
 719                 }
 720
 721                 [Test]
 722                 public void CopyToMultiDimensionalArrayTest ()
 723                 {
 724                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 725
 726                         try {
 727                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 728                                 OdbcCmd.CommandType = CommandType.Text;
 729                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 730                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 731                                 /*OdbcParameter p2Age = */OdbcCmd.Parameters.Add ("@age", OdbcType.Int, 2);
 732
 733                                 Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 734                                 OdbcParameter [,] DestinationParamArray = new OdbcParameter [2, 4];
 735
 736                                 try{
 737                                         OdbcCmd.Parameters.CopyTo (DestinationParamArray, 1); //DestinationParamArray is multi Dimensional
 738                                         Assert.Fail ("Expected Exception ArgumentException not thrown");
 739                                 } catch (ArgumentException) {
 740                                         Assert.AreEqual (null, DestinationParamArray [0, 0], "#2 The DestinationParamArray must remain un-initialized");
 741                                         Assert.AreEqual (null, DestinationParamArray [0, 1], "#3 The DestinationParamArray must remain un-initialized");
 742                                         Assert.AreEqual (null, DestinationParamArray [1, 2], "#4 The DestinationParamArray must remain un-initialized");
 743                                         Assert.AreEqual (null, DestinationParamArray [1, 3], "#5 The DestinationParamArray must remain un-initialized");
 744                                 }
 745                         } finally {
 746                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 747                         }
 748                 }
 749
 750                 [Test]
 751                 public void CopyToLowerBoundCheckTest ()
 752                 {
 753                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 754
 755                         try {
 756                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 757                                 OdbcCmd.CommandType = CommandType.Text;
 758                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 759                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 760                                 /*OdbcParameter p2Age = */OdbcCmd.Parameters.Add ("@age", OdbcType.Int, 2);
 761
 762                                 Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 763                                 OdbcParameter [] DestinationParamArray = new OdbcParameter [4];
 764                                 try {
 765                                         OdbcCmd.Parameters.CopyTo (DestinationParamArray, -1); //index must be >= 0
 766                                         Assert.Fail ("Expected Exception ArgumentOutOfRangeException not thrown");
 767                                 } catch (ArgumentOutOfRangeException) {
 768                                         Assert.AreEqual (null, DestinationParamArray [0], "#2 The DestinationParamArray must remain un-initialized");
 769                                         Assert.AreEqual (null, DestinationParamArray [1], "#3 The DestinationParamArray must remain un-initialized");
 770                                         Assert.AreEqual (null, DestinationParamArray [2], "#4 The DestinationParamArray must remain un-initialized");
 771                                         Assert.AreEqual (null, DestinationParamArray [3], "#5 The DestinationParamArray must remain un-initialized");
 772                                 }
 773                         } finally {
 774                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 775                         }
 776                 }
 777
 778                 [Test]
 779                 public void DuplicateParameterNameTest ()
 780                 {
 781                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 782
 783                         try {
 784                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 785                                 OdbcCmd.CommandType = CommandType.Text;
 786                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 787
 788                                 OdbcParameter p1Lname = OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 789
 790                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 791                                 OdbcParameter p2Lname = OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 792                                 Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#2 Collection should contain 2 parameters");
 793
 794                                 //Checking IndexOf (string) overload
 795                                 Assert.AreEqual (0, OdbcCmd.Parameters.IndexOf ("@lname"));
 796
 797                                 //Checking IndexOf (OdbcParameter) overload
 798                                 Assert.AreEqual (0, OdbcCmd.Parameters.IndexOf (p1Lname));
 799                                 Assert.AreEqual (1, OdbcCmd.Parameters.IndexOf (p2Lname));
 800
 801                                 //Checking IndexOf (object) overload
 802                                 Assert.AreEqual (0, OdbcCmd.Parameters.IndexOf ((object) p1Lname));
 803                                 Assert.AreEqual (1, OdbcCmd.Parameters.IndexOf ((object) p2Lname));
 804                         } finally {
 805                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 806                         }
 807                 }
 808
 809                 [Test]
 810                 public void RemoveTest ()
 811                 {
 812                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 813
 814                         try {
 815                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 816                                 OdbcCmd.CommandType = CommandType.Text;
 817                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 818
 819                                 OdbcParameter p1Lname = OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 820
 821                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 822                                 OdbcCmd.Parameters.Remove (p1Lname);
 823                                 Assert.AreEqual (0, OdbcCmd.Parameters.Count, "#2 Collection should not contain any parameters");
 824                         } finally {
 825                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 826                         }
 827                 }
 828
 829                 [Test]
 830                 public void RemoveNullTest ()
 831                 {
 832                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 833
 834                         try {
 835                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 836                                 OdbcCmd.CommandType = CommandType.Text;
 837                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 838
 839                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 840
 841                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 842                                 try {
 843                                         OdbcCmd.Parameters.Remove (null);
 844                                         Assert.Fail ("Expected exception ArgumentNullException was not thrown");
 845                                 } catch (ArgumentNullException) {
 846                                         Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#2 The collection must contain only one parameter");
 847                                 }
 848                         } finally {
 849                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 850                         }
 851                 }
 852
 853                 [Test]
 854                 public void RemoveEmptyTest ()
 855                 {
 856                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 857
 858                         try {
 859                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 860                                 OdbcCmd.CommandType = CommandType.Text;
 861                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 862
 863                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 864
 865                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 866                                 try {
 867                                         OdbcCmd.Parameters.Remove (string.Empty);
 868                                         Assert.Fail ("Expected exception InvalidCastException was not thrown");
 869                                 } catch (InvalidCastException) {
 870                                         Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#2 The collection must contain only one parameter");
 871                                 }
 872                         } finally {
 873                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 874                         }
 875                 }
 876
 877                 [Test]
 878                 public void RemoveNonOdbcParameterTest ()
 879                 {
 880                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 881
 882                         try {
 883                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 884                                 OdbcCmd.CommandType = CommandType.Text;
 885                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 886
 887                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 888
 889                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 890                                 try {
 891                                         OdbcCmd.Parameters.Remove (4);
 892                                         Assert.Fail ("Expected exception InvalidCastException was not thrown");
 893                                 } catch (InvalidCastException) {
 894                                         Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#2 The collection must contain only one parameter");
 895                                 }
 896                         } finally {
 897                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 898                         }
 899                 }
 900
 901                 [Test]
 902                 public void RemoveNonExistingParameterTest ()
 903                 {
 904                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 905
 906                         try {
 907                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 908                                 OdbcCmd.CommandType = CommandType.Text;
 909                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 910
 911                                 OdbcParameter p1Lname = OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 912                                 /*OdbcParameter p2Age = new OdbcParameter ();*/
 913
 914                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 915                                 OdbcCmd.Parameters.Remove (p1Lname);
 916                                 Assert.AreEqual (0, OdbcCmd.Parameters.Count, "#2 Collection should not contain any parameters");
 917                                 try {
 918                                         OdbcCmd.Parameters.Remove (p1Lname);
 919                                         Assert.Fail ("Expected exception ArgumentException not thrown");
 920                                 } catch (ArgumentException) {
 921                                         Assert.AreEqual (0, OdbcCmd.Parameters.Count, "#3 The collection should not contain any parameters");
 922                                 }
 923                         } finally {
 924                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 925                         }
 926                 }
 927
 928                 [Test]
 929                 public void RemoveParameterContainedInAnotherCollTest ()
 930                 {
 931                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 932
 933                         try {
 934                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 935                                 OdbcCmd.CommandType = CommandType.Text;
 936                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 937
 938                                 OdbcCommand OdbcCmd2 = conn.CreateCommand ();
 939                                 OdbcCmd2.CommandType = CommandType.Text;
 940                                 OdbcCmd2.CommandText = "SELECT lname FROM employee WHERE fname=? AND age=?";
 941
 942                                 OdbcParameter p1 = OdbcCmd.Parameters.Add ("@p1", OdbcType.Text, 15);
 943                                 /*OdbcParameter p2 = */OdbcCmd.Parameters.Add ("@p2", OdbcType.Text, 15);
 944
 945                                 /*OdbcParameter p3 = */OdbcCmd2.Parameters.Add ("@p3", OdbcType.Text, 15);
 946                                 /*OdbcParameter p4 = */OdbcCmd2.Parameters.Add ("@p4", OdbcType.Text, 15);
 947
 948                                 Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#5 The parameter collection of OdbcCmd should contain 2 parameters");
 949                                 Assert.AreEqual (2, OdbcCmd2.Parameters.Count, "#6 The parameter collection of OdbcCmd2 should contain 2 parameters");
 950                                 try {
 951                                         OdbcCmd2.Parameters.Remove (p1);
 952                                         Assert.Fail ("Expected Exception ArgumentException not thrown");
 953                                 } catch (ArgumentException) {
 954                                         Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#5 The parameter collection of OdbcCmd should contain 2 parameters");
 955                                         Assert.AreEqual (2, OdbcCmd2.Parameters.Count, "#6 The parameter collection of OdbcCmd2 should contain 2 parameters");
 956                                 }
 957                         } finally {
 958                                 ConnectionManager.Instance.Odbc.CloseConnection ();
 959                         }
 960                 }
 961
 962                 [Test]
 963                 public void RemoveAtTest ()
 964                 {
 965                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 966
 967                         try {
 968                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
 969                                 OdbcCmd.CommandType = CommandType.Text;
 970                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
 971
 972                                 OdbcParameter p1Lname = OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
 973                                 OdbcParameter p2Age = OdbcCmd.Parameters.Add ("@age", OdbcType.Int, 2);
 974                                 OdbcParameter p3Tmp = OdbcCmd.Parameters.Add ("@p3Tmp", OdbcType.Text, 15);
 975                                 OdbcParameter p4Tmp = OdbcCmd.Parameters.Add ("@p4Tmp", OdbcType.Text, 15);
 976
 977                                 Assert.AreEqual (4, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
 978
 979                                 Assert.AreEqual (true, OdbcCmd.Parameters.Contains(p1Lname), "#2 the collection does not contain p1Lname");
 980                                 Assert.AreEqual (0, OdbcCmd.Parameters.IndexOf(p1Lname), "#3 p1Lname is not at index 0");
 981
 982                                 //remove the first parameter
 983                                 OdbcCmd.Parameters.RemoveAt (0);
 984                                 Assert.AreEqual (3, OdbcCmd.Parameters.Count, "#4 Collection should contain only 3 parameters");
 985                                 Assert.AreEqual (false, OdbcCmd.Parameters.Contains(p1Lname), "#5 the collection should not contain p1Lname");
 986                                 Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf(p1Lname), "#6 the collection should not contain p1Lname");
 987                                 Assert.AreEqual (0, OdbcCmd.Parameters.IndexOf(p2Age), "#7 p2Age should now be at index 0");
 988                                 Assert.AreEqual (1, OdbcCmd.Parameters.IndexOf(p3Tmp), "#8 p3Tmp should now be at index 1");
 989                                 Assert.AreEqual (2, OdbcCmd.Parameters.IndexOf(p4Tmp), "#9 p4Tmp should now be at index 2");
 990
 991                                 //remove the last parameter
 992                                 OdbcCmd.Parameters.RemoveAt (OdbcCmd.Parameters.Count-1);
 993                                 Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#10 Collection should contain only 2 parameters");
 994                                 Assert.AreEqual (false, OdbcCmd.Parameters.Contains(p4Tmp), "#11 the collection should not contain p4Tmp");
 995                                 Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf(p4Tmp), "#12 the collection should not contain p4Tmp");
 996                                 Assert.AreEqual (0, OdbcCmd.Parameters.IndexOf(p2Age), "#13 p2Age should be at index 0");
 997                                 Assert.AreEqual (1, OdbcCmd.Parameters.IndexOf(p3Tmp), "#14 p3Tmp should be at index 1");
 998                         } finally {
 999                                 ConnectionManager.Instance.Odbc.CloseConnection ();
1000                         }
1001                 }
1002
1003                 [Test]
1004                 public void RemoveAtOutOfRangeIndexTest ()
1005                 {
1006                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
1007
1008                         try {
1009                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
1010                                 OdbcCmd.CommandType = CommandType.Text;
1011                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
1012
1013                                 OdbcParameter p1Lname = OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
1014
1015                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
1016                                 try {
1017                                         OdbcCmd.Parameters.RemoveAt (9);
1018                                         Assert.Fail ("Expected exception IndexOutOfRangeException not thrown");
1019                                 } catch (IndexOutOfRangeException) {
1020                                         Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#2 The collection must contain 1 parameter");
1021                                         Assert.AreEqual (true, OdbcCmd.Parameters.Contains(p1Lname), "#3 the collection does not contain p1Lname");
1022                                         Assert.AreEqual (0, OdbcCmd.Parameters.IndexOf(p1Lname), "#4 p1Lname is not at index 0");
1023                                 }
1024                         } finally {
1025                                 ConnectionManager.Instance.Odbc.CloseConnection ();
1026                         }
1027                 }
1028
1029                 [Test]
1030                 public void RemoveAtNegativeIndexTest ()
1031                 {
1032                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
1033
1034                         try {
1035                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
1036                                 OdbcCmd.CommandType = CommandType.Text;
1037                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
1038
1039                                 OdbcParameter p1Lname = OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
1040
1041                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
1042                                 try {
1043                                         OdbcCmd.Parameters.RemoveAt (-1);
1044                                         Assert.Fail ("Expected exception IndexOutOfRangeException not thrown");
1045                                 } catch (IndexOutOfRangeException) {
1046                                         Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#2 The collection must contain 1 parameter");
1047                                         Assert.AreEqual (true, OdbcCmd.Parameters.Contains(p1Lname), "#3 the collection does not contain p1Lname");
1048                                         Assert.AreEqual (0, OdbcCmd.Parameters.IndexOf(p1Lname), "#4 p1Lname is not at index 0");
1049                                 }
1050                         } finally {
1051                                 ConnectionManager.Instance.Odbc.CloseConnection ();
1052                         }
1053                 }
1054
1055                 [Test]
1056                 public void RemoveAtBoundaryTest ()
1057                 {
1058                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
1059
1060                         try {
1061                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
1062                                 OdbcCmd.CommandType = CommandType.Text;
1063                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
1064
1065                                 OdbcParameter p1Lname = OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
1066
1067                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
1068                                 try {
1069                                         OdbcCmd.Parameters.RemoveAt (OdbcCmd.Parameters.Count);
1070                                         Assert.Fail ("Expected exception IndexOutOfRangeException not thrown");
1071                                 } catch (IndexOutOfRangeException) {
1072                                         Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#2 The collection must contain 1 parameter");
1073                                         Assert.AreEqual (true, OdbcCmd.Parameters.Contains(p1Lname), "#3 the collection does not contain p1Lname");
1074                                         Assert.AreEqual (0, OdbcCmd.Parameters.IndexOf(p1Lname), "#4 p1Lname is not at index 0");
1075                                 }
1076                         } finally {
1077                                 ConnectionManager.Instance.Odbc.CloseConnection ();
1078                         }
1079                 }
1080
1081                 [Test]
1082                 public void AddWithValueTest ()
1083                 {
1084                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
1085
1086                         try {
1087                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
1088                                 OdbcCmd.CommandType = CommandType.Text;
1089                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
1090
1091                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
1092                                 OdbcParameter rt = null; //to check return type
1093                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
1094
1095                                 rt = OdbcCmd.Parameters.AddWithValue ("@P2", "Param2");
1096                                 Assert.AreEqual (typeof(OdbcParameter), rt.GetType(), "#1a AddWithValue didnt retuen type OdbcParameter");
1097                                 Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#2 AddWithValue failed for valid parameter name and value");
1098                                 Assert.AreEqual (true, OdbcCmd.Parameters.Contains ("@P2"), "#3 collection does not contain @P2");
1099                                 Assert.AreEqual (1, OdbcCmd.Parameters.IndexOf ("@P2"), "#4 Index of added parameter must be 1");
1100                                 Assert.AreEqual ("Param2", OdbcCmd.Parameters["@P2"].Value, "#5 Value of added parameter must be Param2");
1101                                 Assert.AreEqual (OdbcType.NVarChar,OdbcCmd.Parameters[1].OdbcType, "#6 Parameters with null value must be of type NVarChar");
1102
1103                                 OdbcCmd.Parameters.AddWithValue ("@P2", "Param2ReAdded"); //adding again
1104                                 Assert.AreEqual (3, OdbcCmd.Parameters.Count, "#7 AddWithValue must append at the end of the collection even for same parameter names");
1105                                 Assert.AreEqual (true, OdbcCmd.Parameters.Contains ("@P2"), "#8 collection does not contain @P2");
1106                                 Assert.AreEqual (1, OdbcCmd.Parameters.IndexOf ("@P2"), "#9 Index of @P2 must be 1");
1107                                 Assert.AreEqual ("Param2", OdbcCmd.Parameters["@P2"].Value, "#10 Value of added parameter must be Param2");
1108                                 Assert.AreEqual (OdbcType.NVarChar,OdbcCmd.Parameters["@P2"].OdbcType, "#11 Parameters with null value must be of type NVarChar");
1109
1110                                 //Two different parameters with same name but at different positions ie 1 and 2
1111                                 Assert.AreEqual ("@P2",OdbcCmd.Parameters[1].ParameterName, "#12 The parameter at index 1 must be @P2");
1112                                 Assert.AreEqual ("@P2",OdbcCmd.Parameters[2].ParameterName, "#13 The parameter at index 2 must be @P2");
1113
1114                                 //Confirming the parameters by checking their values
1115                                 Assert.AreEqual ("Param2",OdbcCmd.Parameters[1].Value, "#14The parameter at index 1 must have value Param2");
1116                                 Assert.AreEqual ("Param2ReAdded",OdbcCmd.Parameters[2].Value, "#15The parameter at index 2 must have value Param2ReAdded");
1117
1118                                 //Testing for null values
1119                                 OdbcCmd.Parameters.AddWithValue (null, null);
1120                                 Assert.AreEqual (4, OdbcCmd.Parameters.Count, "#16 AddWithValue must accept null parameter names and null values");
1121                                 Assert.AreEqual (false, OdbcCmd.Parameters.Contains (null), "#17 AddWithValue must return false for Contains (null)");
1122                                 Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf (null), "#18 AddWithValue must return -1 for IndexOf (null)");
1123                                 Assert.AreEqual (null, OdbcCmd.Parameters["Parameter1"].Value, "#19 Value of added parameter must be null");
1124                                 Assert.AreEqual ("Parameter1",OdbcCmd.Parameters[3].ParameterName, "#20 The parameter at index 3 must be Parameter1");
1125                                 Assert.AreEqual (OdbcType.NVarChar,OdbcCmd.Parameters[3].OdbcType, "#21 Parameters with null value must be of type NVarChar");
1126
1127                                 OdbcCmd.Parameters.AddWithValue (null, null); //adding another null parameter
1128                                 Assert.AreEqual (5, OdbcCmd.Parameters.Count, "#22 AddWithValue must accept null parameter names and null values");
1129                                 Assert.AreEqual (false, OdbcCmd.Parameters.Contains (null), "#23 AddWithValue must return false for Contains (null)");
1130                                 Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf (null), "#24 AddWithValue must return -1 for IndexOf (null)");
1131                                 Assert.AreEqual (null, OdbcCmd.Parameters["Parameter2"].Value, "#25 Value of added parameter must be null");
1132                                 Assert.AreEqual ("Parameter2",OdbcCmd.Parameters[4].ParameterName, "#26 The parameter at index 1 must be Parameter2");
1133                                 Assert.AreEqual (OdbcType.NVarChar,OdbcCmd.Parameters[4].OdbcType, "#27 Parameters with null value must be of type NVarChar");
1134
1135                                 //Testing for empty strings
1136                                 OdbcCmd.Parameters.AddWithValue ("", ""); //adding empty parameter
1137                                 Assert.AreEqual (6, OdbcCmd.Parameters.Count, "#28 AddWithValue must accept empty names and empty values");
1138                                 Assert.AreEqual (false, OdbcCmd.Parameters.Contains (""), "#29 AddWithValue must return false for Contains ('')");
1139                                 Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf (""), "#30 AddWithValue must return -1 for IndexOf ('')");
1140                                 Assert.AreEqual ("Parameter3",OdbcCmd.Parameters[5].ParameterName, "#31 The parameter at index 5 must be Parameter3");
1141                                 Assert.AreEqual ("",OdbcCmd.Parameters[5].Value, "#32 The parameter at index 5 must have value as empty string");
1142                                 Assert.AreEqual (OdbcType.NVarChar,OdbcCmd.Parameters[5].OdbcType, "#33 Parameters with null value must be of type NVarChar");
1143
1144                                 OdbcCmd.Parameters.AddWithValue ("", ""); //adding another empty parameter
1145                                 Assert.AreEqual (7, OdbcCmd.Parameters.Count, "#34 AddWithValue must accept empty names and empty values");
1146                                 Assert.AreEqual (false, OdbcCmd.Parameters.Contains (""), "#35 AddWithValue must return false for Contains ('')");
1147                                 Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf (""), "#36 AddWithValue must return -1 for IndexOf ('')");
1148                                 Assert.AreEqual ("Parameter4",OdbcCmd.Parameters[6].ParameterName, "#37 The parameter at index 6 must have name as Parameter4");
1149                                 Assert.AreEqual ("",OdbcCmd.Parameters[6].Value, "#38 The parameter at index 6 must have value as empty string");
1150                                 Assert.AreEqual (OdbcType.NVarChar,OdbcCmd.Parameters[6].OdbcType, "#39 Parameters with null value must be of type NVarChar");
1151
1152                                 OdbcCmd.Parameters.AddWithValue ("foo", null);
1153                                 Assert.AreEqual (8, OdbcCmd.Parameters.Count, "#40 AddWithValue must accept string names and null values");
1154                                 Assert.AreEqual (true, OdbcCmd.Parameters.Contains ("foo"), "#41 AddWithValue must return true for Contains ('foo')");
1155                                 Assert.AreEqual (7, OdbcCmd.Parameters.IndexOf ("foo"), "#42 AddWithValue must return 7 for IndexOf ('foo')");
1156                                 Assert.AreEqual ("foo",OdbcCmd.Parameters[7].ParameterName, "#43 The parameter at index 7 must have name foo");
1157                                 Assert.AreEqual (null,OdbcCmd.Parameters[7].Value, "#44 The parameter at index 7 must have value as null");
1158                                 Assert.AreEqual (OdbcType.NVarChar,OdbcCmd.Parameters[7].OdbcType, "#45 Parameters with null value must be of type NVarChar");
1159
1160                                 OdbcCmd.Parameters.AddWithValue (null, 2);
1161                                 Assert.AreEqual (9, OdbcCmd.Parameters.Count, "#46 AddWithValue must accept empty names and empty values");
1162                                 Assert.AreEqual (false, OdbcCmd.Parameters.Contains (null), "#47 AddWithValue must return false for Contains (null)");
1163                                 Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf (null), "#48 AddWithValue must return -1 for IndexOf ('')");
1164                                 Assert.AreEqual ("Parameter5",OdbcCmd.Parameters[8].ParameterName, "#49 The parameter at index 8 must have name as Parameter5");
1165                                 Assert.AreEqual (2,OdbcCmd.Parameters[8].Value, "#50 The parameter at index 8 must have value as 2");
1166                                 Assert.AreEqual (OdbcType.NVarChar,OdbcCmd.Parameters[8].OdbcType, "#51 Parameter must be of type NVarChar");
1167                         } finally {
1168                                 ConnectionManager.Instance.Odbc.CloseConnection ();
1169                         }
1170                 }
1171
1172                 [Test]
1173                 public void DefaultNamesAndValuesTest ()
1174                 {
1175                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
1176
1177                         try {
1178                                 OdbcCommand OdbcCmd = conn.CreateCommand ();
1179                                 OdbcCmd.CommandType = CommandType.Text;
1180                                 OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";
1181
1182                                 /*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
1183                                 Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
1184
1185                                 OdbcParameter p2Age = new OdbcParameter ();
1186                                 OdbcParameter p3Tmp = new OdbcParameter ();
1187
1188                                 OdbcCmd.Parameters.Add (p2Age);
1189                                 Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#2 The collection must contain 2 parameters");
1190                                 Assert.AreEqual (true, OdbcCmd.Parameters.Contains (p2Age), "#3 Collection does not contain p2Age");
1191                                 Assert.AreEqual (1, OdbcCmd.Parameters.IndexOf (p2Age), "#4 Index of p2Age must be 1");
1192                                 Assert.AreEqual (null, OdbcCmd.Parameters[1].Value, "#5 Value of added parameter must be null");
1193                                 Assert.AreEqual ("Parameter1",OdbcCmd.Parameters[1].ParameterName, "#6 The parameter must have a default name");
1194                                 Assert.AreEqual (OdbcType.NVarChar,OdbcCmd.Parameters[1].OdbcType, "#7 Parameters with null value must be of type NVarChar");
1195
1196                                 OdbcCmd.Parameters.Insert (2,p3Tmp);
1197                                 Assert.AreEqual (3, OdbcCmd.Parameters.Count, "#8 The collection must contain 3 parameters");
1198                                 Assert.AreEqual (true, OdbcCmd.Parameters.Contains (p3Tmp), "#9 Collection does not contain p3Tmp");
1199                                 Assert.AreEqual (2, OdbcCmd.Parameters.IndexOf (p3Tmp), "#10 Index of p3Tmp must be 2");
1200                                 Assert.AreEqual (null, OdbcCmd.Parameters[2].Value, "#11 Value of added parameter must be null");
1201                                 Assert.AreEqual ("Parameter2",OdbcCmd.Parameters[2].ParameterName, "#12 The parameter must have a default name");
1202                                 Assert.AreEqual (OdbcType.NVarChar,OdbcCmd.Parameters[2].OdbcType, "#13 Parameters with null value must be of type NVarChar");
1203                         } finally {
1204                                 ConnectionManager.Instance.Odbc.CloseConnection ();
1205                         }
1206                 }
1207         }
1208 }
1209
1210 #endif