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