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