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