mcs/class/System.Data.OracleClient/Test/System.Data.OracleClient/OracleParameterCollectionTest.cs

   1 //
   2 // OracleParameterCollectionTest.cs -
   3 //      NUnit Test Cases for OracleParameterCollection
   4 //
   5 // Author:
   6 //      Amit Biswas  <amit@amitbiswas.com>
   7 //
   8 // Copyright (C) 2007 Novell (http://www.novell.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using System;
  31 using System.Data;
  32 using System.Data.OracleClient;
  33 using System.Globalization;
  34 using System.Threading;
  35
  36 using NUnit.Framework;
  37
  38 namespace MonoTests.System.Data.OracleClient
  39 {
  40         [TestFixture]
  41         public class OracleParameterCollectionTest
  42         {
  43                 OracleParameterCollection o;
  44                 CultureInfo oldCulture;
  45
  46                 [SetUp]
  47                 public void SetUp ()
  48                 {
  49                         oldCulture = CultureInfo.CurrentCulture;
  50                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
  51                         o = new OracleParameterCollection ();
  52                 }
  53
  54                 [TearDown]
  55                 public void TearDown ()
  56                 {
  57                         Thread.CurrentThread.CurrentCulture = oldCulture;
  58                 }
  59
  60                 [Test]
  61                 public void Clear ()
  62                 {
  63                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
  64                         OracleParameter paramB = new OracleParameter ("Parami", 2);
  65
  66                         o.Clear ();
  67                         o.Add (paramA);
  68                         o.Add (paramB);
  69                         o.Clear ();
  70
  71                         Assert.AreEqual (0, o.Count, "#1");
  72                         Assert.AreEqual (-1, o.IndexOf (paramA), "#2");
  73                         Assert.AreEqual (-1, o.IndexOf (paramB), "#3");
  74
  75                         o.Add (paramA);
  76                 }
  77
  78                 [Test]
  79                 public void Count ()
  80                 {
  81                         Assert.AreEqual (0, o.Count, "#1");
  82                         o.Add (new OracleParameter ());
  83                         Assert.AreEqual (1, o.Count, "#2");
  84                         o.Add (new OracleParameter ());
  85                         Assert.AreEqual (2, o.Count, "#3");
  86                         o.RemoveAt (0);
  87                         Assert.AreEqual (1, o.Count, "#4");
  88                         o.RemoveAt (0);
  89                         Assert.AreEqual (0, o.Count, "#6");
  90                 }
  91
  92                 [Test]
  93                 public void IsFixedSize ()
  94                 {
  95                         Assert.IsFalse (o.IsFixedSize);
  96                 }
  97
  98                 [Test]
  99                 public void IsReadOnly ()
 100                 {
 101                         Assert.IsFalse (o.IsReadOnly);
 102                 }
 103
 104                 [Test]
 105                 public void IsSynchronized ()
 106                 {
 107                         Assert.IsFalse (o.IsSynchronized);
 108                 }
 109
 110                 [Test] // Add (Object)
 111                 public void Add1_Value_InvalidType ()
 112                 {
 113                         try {
 114                                 o.Add ((object) "ParamI");
 115                                 Assert.Fail ("#A1");
 116                         } catch (InvalidCastException ex) {
 117                                 // The OracleParameterCollection only accepts
 118                                 // non-null OracleParameter type objects, not
 119                                 // String objects
 120                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#A2");
 121                                 Assert.IsNull (ex.InnerException, "#A3");
 122                                 Assert.IsNotNull (ex.Message, "#A4");
 123 #if NET_2_0
 124                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 125                                 Assert.IsTrue (ex.Message.IndexOf (typeof (string).Name) != -1, "#A6");
 126 #endif
 127                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#A7");
 128                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A8");
 129                         }
 130
 131                         try {
 132                                 o.Add ((object) 5);
 133                                 Assert.Fail ("#B1");
 134                         } catch (InvalidCastException ex) {
 135                                 // The OracleParameterCollection only accepts
 136                                 // non-null OracleParameter type objects, not
 137                                 // String objects
 138                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#B2");
 139                                 Assert.IsNull (ex.InnerException, "#B3");
 140                                 Assert.IsNotNull (ex.Message, "#B4");
 141 #if NET_2_0
 142                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
 143                                 Assert.IsFalse (ex.Message.IndexOf (typeof (string).Name) != -1, "#B6");
 144                                 Assert.IsTrue (ex.Message.IndexOf (typeof (int).Name) != -1, "#B7");
 145 #endif
 146                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B8");
 147                         }
 148                 }
 149
 150                 [Test] // Add (Object)
 151                 public void Add1_Value_Null ()
 152                 {
 153                         try {
 154                                 o.Add ((object) null);
 155                                 Assert.Fail ("#1");
 156                         } catch (ArgumentNullException ex) {
 157 #if NET_2_0
 158                                 // The OracleParameterCollection only accepts
 159                                 // non-null OracleParameter type objects
 160                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 161                                 Assert.IsNull (ex.InnerException, "#3");
 162                                 Assert.IsNotNull (ex.Message, "#4");
 163                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
 164                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
 165                                 Assert.AreEqual ("value", ex.ParamName, "#7");
 166 #else
 167                                 // Value cannot be null
 168                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 169                                 Assert.IsNull (ex.InnerException, "#3");
 170                                 Assert.IsNotNull (ex.Message, "#4");
 171                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
 172                                 Assert.IsFalse (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
 173                                 Assert.AreEqual ("value", ex.ParamName, "#7");
 174 #endif
 175                         }
 176                 }
 177
 178                 [Test] // Add (Object)
 179                 public void Add1_Value_Owned ()
 180                 {
 181                         OracleParameter param = new OracleParameter ("ParamI", 1);
 182
 183                         o.Add ((object) param);
 184
 185                         // attempt to add same OracleParameter to collection twice
 186                         try {
 187                                 o.Add ((object) param);
 188                                 Assert.Fail ("#A1");
 189                         } catch (ArgumentException ex) {
 190                                 // The OracleParameter is already contained by
 191                                 // another OracleParameterCollection
 192                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 193                                 Assert.IsNull (ex.InnerException, "#A3");
 194                                 Assert.IsNotNull (ex.Message, "#A4");
 195                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 196                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
 197                                 Assert.IsNull (ex.ParamName, "#A7");
 198                         }
 199
 200                         OracleParameterCollection o2 = new OracleParameterCollection ();
 201
 202                         // attempt to add OracleParameter to another collection
 203                         try {
 204                                 o2.Add ((object) param);
 205                                 Assert.Fail ("#B1");
 206                         } catch (ArgumentException ex) {
 207                                 // The OracleParameter is already contained by
 208                                 // another OracleParameterCollection
 209                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 210                                 Assert.IsNull (ex.InnerException, "#B3");
 211                                 Assert.IsNotNull (ex.Message, "#B4");
 212                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
 213                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B6");
 214                                 Assert.IsNull (ex.ParamName, "#B7");
 215                         }
 216
 217                         o.Remove ((object) param);
 218                         o.Add ((object) param);
 219                         o.Remove ((object) param);
 220                         o2.Add ((object) param);
 221                 }
 222
 223                 [Test] // Add (OracleParameter)
 224                 public void Add2_Value_Null ()
 225                 {
 226                         try {
 227                                 o.Add ((OracleParameter) null);
 228                                 Assert.Fail ("#1");
 229 #if NET_2_0
 230                         } catch (ArgumentNullException ex) {
 231                                 // The OracleParameterCollection only accepts
 232                                 // non-null OracleParameter type objects
 233                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 234                                 Assert.IsNull (ex.InnerException, "#3");
 235                                 Assert.IsNotNull (ex.Message, "#4");
 236                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
 237                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
 238                                 Assert.AreEqual ("value", ex.ParamName, "#7");
 239                         }
 240 #else
 241                         } catch (NullReferenceException ex) {
 242                                 Assert.AreEqual (typeof (NullReferenceException), ex.GetType (), "#2");
 243                                 Assert.IsNull (ex.InnerException, "#3");
 244                                 Assert.IsNotNull (ex.Message, "#4");
 245                         }
 246 #endif
 247                 }
 248
 249                 [Test] // Add (OracleParameter)
 250                 public void Add2_Value_Owned ()
 251                 {
 252                         OracleParameter param = new OracleParameter ("ParamI", 1);
 253
 254                         o.Add (param);
 255
 256                         // attempt to add same OracleParameter to collection twice
 257                         try {
 258                                 o.Add (param);
 259                                 Assert.Fail ("#A1");
 260                         } catch (ArgumentException ex) {
 261                                 // The OracleParameter is already contained by
 262                                 // another OracleParameterCollection
 263                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 264                                 Assert.IsNull (ex.InnerException, "#A3");
 265                                 Assert.IsNotNull (ex.Message, "#A4");
 266                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 267                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
 268                                 Assert.IsNull (ex.ParamName, "#A7");
 269                         }
 270
 271                         OracleParameterCollection o2 = new OracleParameterCollection ();
 272
 273                         // attempt to add OracleParameter to another collection
 274                         try {
 275                                 o2.Add (param);
 276                                 Assert.Fail ("#B1");
 277                         } catch (ArgumentException ex) {
 278                                 // The OracleParameter is already contained by
 279                                 // another OracleParameterCollection
 280                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 281                                 Assert.IsNull (ex.InnerException, "#B3");
 282                                 Assert.IsNotNull (ex.Message, "#B4");
 283                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
 284                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B6");
 285                                 Assert.IsNull (ex.ParamName, "#B7");
 286                         }
 287
 288                         o.Remove (param);
 289                         o.Add (param);
 290                         o.Remove (param);
 291                         o2.Add (param);
 292                 }
 293
 294 #if NET_2_0
 295                 [Test] // AddRange (Array)
 296                 public void AddRange1 ()
 297                 {
 298                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 299                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 300                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 301                         OracleParameter paramD = new OracleParameter ("parami", 4);
 302
 303                         o.Add (paramA);
 304                         o.AddRange (new object [] { paramB, paramC, paramD });
 305
 306                         Assert.AreEqual (0, o.IndexOf (paramA), "#1");
 307                         Assert.AreEqual (1, o.IndexOf (paramB), "#2");
 308                         Assert.AreEqual (2, o.IndexOf (paramC), "#3");
 309                         Assert.AreEqual (3, o.IndexOf (paramD), "#4");
 310                 }
 311
 312                 [Test] // AddRange (Array)
 313                 public void AddRange1_Item_InvalidType ()
 314                 {
 315                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 316                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 317                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 318
 319                         o.Add (paramA);
 320
 321                         object [] values = new object [] { paramB, "ParamX", paramC };
 322                         try {
 323                                 o.AddRange (values);
 324                                 Assert.Fail ("#A1");
 325                         } catch (InvalidCastException ex) {
 326                                 // The OracleParameterCollection only accepts
 327                                 // non-null OracleParameter type objects, not
 328                                 // String objects
 329                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#A2");
 330                                 Assert.IsNull (ex.InnerException, "#A3");
 331                                 Assert.IsNotNull (ex.Message, "#A4");
 332                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 333                                 Assert.IsTrue (ex.Message.IndexOf (typeof (string).Name) != -1, "#A6");
 334                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#A7");
 335                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A8");
 336                         }
 337
 338                         Assert.AreEqual (0, o.IndexOf (paramA), "#B1");
 339                         Assert.AreEqual (-1, o.IndexOf (paramB), "#B2");
 340                         Assert.AreEqual (-1, o.IndexOf (paramC), "#B3");
 341                 }
 342
 343                 [Test] // AddRange (Array)
 344                 public void AddRange1_Item_Null ()
 345                 {
 346                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 347                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 348                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 349
 350                         o.Add (paramA);
 351
 352                         object [] values = new object [] { paramB, null, paramC };
 353                         try {
 354                                 o.AddRange (values);
 355                                 Assert.Fail ("#A1");
 356                         } catch (ArgumentNullException ex) {
 357                                 // The OracleParameterCollection only accepts
 358                                 // non-null OracleParameter type objects
 359                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 360                                 Assert.IsNull (ex.InnerException, "#A3");
 361                                 Assert.IsNotNull (ex.Message, "#A4");
 362                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 363                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
 364                                 Assert.AreEqual ("value", ex.ParamName, "#A7");
 365                         }
 366
 367                         Assert.AreEqual (0, o.IndexOf (paramA), "#B1");
 368                         Assert.AreEqual (-1, o.IndexOf (paramB), "#B2");
 369                         Assert.AreEqual (-1, o.IndexOf (paramC), "#B3");
 370                 }
 371
 372                 [Test] // AddRange (Array)
 373                 public void AddRange1_Item_Owned ()
 374                 {
 375                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 376                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 377                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 378
 379                         o.Add (paramA);
 380
 381                         object [] values = new object [] { paramB, paramA, paramC };
 382                         try {
 383                                 o.AddRange (values);
 384                                 Assert.Fail ("#A1");
 385                         } catch (ArgumentException ex) {
 386                                 // The OracleParameter is already contained by
 387                                 // another OracleParameterCollection
 388                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 389                                 Assert.IsNull (ex.InnerException, "#A3");
 390                                 Assert.IsNotNull (ex.Message, "#A4");
 391                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 392                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
 393                                 Assert.IsNull (ex.ParamName, "#A7");
 394                         }
 395
 396                         Assert.AreEqual (0, o.IndexOf (paramA), "#B1");
 397                         Assert.AreEqual (1, o.IndexOf (paramB), "#B2");
 398                         Assert.AreEqual (-1, o.IndexOf (paramC), "#B3");
 399                 }
 400
 401                 [Test] // AddRange (Array)
 402                 public void AddRange1_Values_Null ()
 403                 {
 404                         try {
 405                                 o.AddRange ((Array) null);
 406                                 Assert.Fail ("#1");
 407                         } catch (ArgumentNullException ex) {
 408                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 409                                 Assert.IsNull (ex.InnerException, "#3");
 410                                 Assert.IsNotNull (ex.Message, "#4");
 411                                 Assert.AreEqual ("values", ex.ParamName, "#5");
 412                         }
 413                 }
 414
 415                 [Test] // AddRange (OracleParameter [])
 416                 public void AddRange2 ()
 417                 {
 418                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 419                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 420                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 421                         OracleParameter paramD = new OracleParameter ("parami", 4);
 422
 423                         o.Add (paramA);
 424
 425                         OracleParameter [] values = new OracleParameter [] {
 426                                 paramB, paramC, paramD };
 427                         o.AddRange (values);
 428
 429                         Assert.AreEqual (0, o.IndexOf (paramA), "#1");
 430                         Assert.AreEqual (1, o.IndexOf (paramB), "#2");
 431                         Assert.AreEqual (2, o.IndexOf (paramC), "#3");
 432                         Assert.AreEqual (3, o.IndexOf (paramD), "#4");
 433                 }
 434
 435                 [Test] // AddRange (OracleParameter [])
 436                 public void AddRange2_Item_Null ()
 437                 {
 438                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 439                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 440                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 441
 442                         o.Add (paramA);
 443
 444                         OracleParameter [] values = new OracleParameter [] {
 445                                 paramB, null, paramC };
 446                         try {
 447                                 o.AddRange (values);
 448                                 Assert.Fail ("#A1");
 449                         } catch (ArgumentNullException ex) {
 450                                 // The OracleParameterCollection only accepts
 451                                 // non-null OracleParameter type objects
 452                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 453                                 Assert.IsNull (ex.InnerException, "#A3");
 454                                 Assert.IsNotNull (ex.Message, "#A4");
 455                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 456                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
 457                                 Assert.AreEqual ("value", ex.ParamName, "#A7");
 458                         }
 459
 460                         Assert.AreEqual (0, o.IndexOf (paramA), "#B1");
 461                         Assert.AreEqual (-1, o.IndexOf (paramB), "#B2");
 462                         Assert.AreEqual (-1, o.IndexOf (paramC), "#B3");
 463                 }
 464
 465                 [Test] // AddRange (OracleParameter [])
 466                 public void AddRange2_Item_Owned ()
 467                 {
 468                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 469                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 470                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 471
 472                         o.Add (paramA);
 473
 474                         OracleParameter [] values = new OracleParameter [] {
 475                                 paramB, paramA, paramC };
 476                         try {
 477                                 o.AddRange (values);
 478                                 Assert.Fail ("#A1");
 479                         } catch (ArgumentException ex) {
 480                                 // The OracleParameter is already contained by
 481                                 // another OracleParameterCollection
 482                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 483                                 Assert.IsNull (ex.InnerException, "#A3");
 484                                 Assert.IsNotNull (ex.Message, "#A4");
 485                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 486                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
 487                                 Assert.IsNull (ex.ParamName, "#A7");
 488                         }
 489
 490                         Assert.AreEqual (0, o.IndexOf (paramA), "#B1");
 491                         Assert.AreEqual (1, o.IndexOf (paramB), "#B2");
 492                         Assert.AreEqual (-1, o.IndexOf (paramC), "#B3");
 493                 }
 494
 495                 [Test] // AddRange (OracleParameter [])
 496                 public void AddRange2_Values_Null ()
 497                 {
 498                         try {
 499                                 o.AddRange ((OracleParameter []) null);
 500                                 Assert.Fail ("#1");
 501                         } catch (ArgumentNullException ex) {
 502                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 503                                 Assert.IsNull (ex.InnerException, "#3");
 504                                 Assert.IsNotNull (ex.Message, "#4");
 505                                 Assert.AreEqual ("values", ex.ParamName, "#5");
 506                         }
 507                 }
 508 #endif
 509
 510                 [Test] // Contains (Object)
 511                 public void Contains1 ()
 512                 {
 513                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 514                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 515                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 516                         OracleParameter paramD = new OracleParameter ("parami", 4);
 517
 518                         o.Add (paramA);
 519                         o.Add (paramB);
 520
 521                         Assert.IsTrue (o.Contains ((object) paramA), "#A1");
 522                         Assert.IsTrue (o.Contains ((object) paramB), "#A2");
 523                         Assert.IsFalse (o.Contains ((object) paramC), "#A3");
 524                         Assert.IsFalse (o.Contains ((object) paramD), "#A4");
 525                         Assert.IsFalse (o.Contains ((object) null), "#A5");
 526
 527                         o.Add (paramC);
 528
 529                         Assert.IsTrue (o.Contains ((object) paramA), "#B1");
 530                         Assert.IsTrue (o.Contains ((object) paramB), "#B2");
 531                         Assert.IsTrue (o.Contains ((object) paramC), "#B3");
 532                         Assert.IsFalse (o.Contains ((object) paramD), "#B4");
 533                         Assert.IsFalse (o.Contains ((object) null), "#B5");
 534
 535                         o.Remove (paramA);
 536
 537                         Assert.IsFalse (o.Contains ((object) paramA), "#C1");
 538                         Assert.IsTrue (o.Contains ((object) paramB), "#C2");
 539                         Assert.IsTrue (o.Contains ((object) paramC), "#C3");
 540                         Assert.IsFalse (o.Contains ((object) paramD), "#C4");
 541                         Assert.IsFalse (o.Contains ((object) null), "#C5");
 542                 }
 543
 544                 [Test] // Contains (Object)
 545                 public void Contains1_Value_InvalidType ()
 546                 {
 547                         try {
 548                                 o.Contains ((object) "ParamI");
 549                                 Assert.Fail ("#A1");
 550                         } catch (InvalidCastException ex) {
 551                                 // The OracleParameterCollection only accepts
 552                                 // non-null OracleParameter type objects, not
 553                                 // String objects
 554                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#A2");
 555                                 Assert.IsNull (ex.InnerException, "#A3");
 556                                 Assert.IsNotNull (ex.Message, "#A4");
 557 #if NET_2_0
 558                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 559                                 Assert.IsTrue (ex.Message.IndexOf (typeof (string).Name) != -1, "#A6");
 560                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#A7");
 561 #endif
 562                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A8");
 563                         }
 564
 565                         try {
 566                                 o.Contains ((object) 5);
 567                                 Assert.Fail ("#B1");
 568                         } catch (InvalidCastException ex) {
 569                                 // The OracleParameterCollection only accepts
 570                                 // non-null OracleParameter type objects, not
 571                                 // Int32 objects
 572                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#B2");
 573                                 Assert.IsNull (ex.InnerException, "#B3");
 574                                 Assert.IsNotNull (ex.Message, "#B4");
 575 #if NET_2_0
 576                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
 577                                 Assert.IsFalse (ex.Message.IndexOf (typeof (string).Name) != -1, "#B6");
 578                                 Assert.IsTrue (ex.Message.IndexOf (typeof (int).Name) != -1, "#B7");
 579 #endif
 580                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B8");
 581                         }
 582                 }
 583
 584                 [Test] // Contains (OracleParameter)
 585                 public void Contains2 ()
 586                 {
 587                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 588                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 589                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 590                         OracleParameter paramD = new OracleParameter ("parami", 4);
 591
 592                         o.Add (paramA);
 593                         o.Add (paramB);
 594
 595                         Assert.IsTrue (o.Contains (paramA), "#A1");
 596                         Assert.IsTrue (o.Contains (paramB), "#A2");
 597                         Assert.IsFalse (o.Contains (paramC), "#A3");
 598                         Assert.IsFalse (o.Contains (paramD), "#A4");
 599                         Assert.IsFalse (o.Contains ((OracleParameter) null), "#A5");
 600
 601                         o.Add (paramC);
 602
 603                         Assert.IsTrue (o.Contains (paramA), "#B1");
 604                         Assert.IsTrue (o.Contains (paramB), "#B2");
 605                         Assert.IsTrue (o.Contains (paramC), "#B3");
 606                         Assert.IsFalse (o.Contains (paramD), "#B4");
 607                         Assert.IsFalse (o.Contains ((OracleParameter) null), "#B5");
 608
 609                         o.Remove (paramA);
 610
 611                         Assert.IsFalse (o.Contains (paramA), "#C1");
 612                         Assert.IsTrue (o.Contains (paramB), "#C2");
 613                         Assert.IsTrue (o.Contains (paramC), "#C3");
 614                         Assert.IsFalse (o.Contains (paramD), "#C4");
 615                         Assert.IsFalse (o.Contains ((OracleParameter) null), "#C5");
 616                 }
 617
 618                 [Test] // Contains (String)
 619                 public void Contains3 ()
 620                 {
 621                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 622                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 623                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 624                         OracleParameter paramD = new OracleParameter ("parami", 4);
 625
 626                         o.Add (paramA);
 627                         o.Add (paramB);
 628
 629                         Assert.IsTrue (o.Contains ("ParamI"), "#A1");
 630                         Assert.IsTrue (o.Contains ("Parami"), "#A2");
 631                         Assert.IsTrue (o.Contains ("paramI"), "#A3");
 632                         Assert.IsTrue (o.Contains ("parami"), "#A4");
 633                         Assert.IsFalse (o.Contains ("NotFound"), "#A5");
 634                         Assert.IsFalse (o.Contains ((OracleParameter) null), "#A6");
 635
 636                         o.Remove (paramA);
 637
 638                         Assert.IsFalse (o.Contains ("ParamI"), "#B1");
 639                         Assert.IsTrue (o.Contains ("Parami"), "#B2");
 640                         Assert.IsFalse (o.Contains ("paramI"), "#B3");
 641                         Assert.IsTrue (o.Contains ("parami"), "#B4");
 642                         Assert.IsFalse (o.Contains ("NotFound"), "#B5");
 643                         Assert.IsFalse (o.Contains ((OracleParameter) null), "#B6");
 644                 }
 645
 646                 [Test] // OracleParameter this [Int32]
 647                 public void Indexer1 ()
 648                 {
 649                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 650                         OracleParameter paramB = new OracleParameter ("paramI", 2);
 651                         OracleParameter paramC = new OracleParameter ("Parami", 3);
 652
 653                         o.Add (paramA);
 654                         o.Add (paramB);
 655
 656                         Assert.AreSame (paramA, o [0], "#A1");
 657                         Assert.AreSame (paramB, o [1], "#A2");
 658                         o [0] = paramA;
 659                         Assert.AreSame (paramA, o [0], "#B1");
 660                         Assert.AreSame (paramB, o [1], "#B2");
 661                         o [0] = paramC;
 662                         Assert.AreSame (paramC, o [0], "#C1");
 663                         Assert.AreSame (paramB, o [1], "#C2");
 664                         o [1] = paramA;
 665                         Assert.AreSame (paramC, o [0], "#D1");
 666                         Assert.AreSame (paramA, o [1], "#D2");
 667
 668                         OracleParameterCollection o2 = new OracleParameterCollection ();
 669                         o2.Add (paramB);
 670                 }
 671
 672                 [Test] // OracleParameter this [Int32]
 673                 public void Indexer1_Index_Invalid ()
 674                 {
 675                         o.Add (new OracleParameter ());
 676
 677                         try {
 678                                 o [1] = new OracleParameter ();
 679                                 Assert.Fail ("#A1");
 680                         } catch (IndexOutOfRangeException ex) {
 681 #if NET_2_0
 682                                 // Invalid index 1 for this OracleParameterCollection
 683                                 // with Count=1
 684                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
 685                                 Assert.IsNull (ex.InnerException, "#A3");
 686                                 Assert.IsNotNull (ex.Message, "#A4");
 687                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 688 #else
 689                                 // Index 1 outside the scope of the parameter array
 690                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
 691                                 Assert.IsNull (ex.InnerException, "#A3");
 692                                 Assert.IsNotNull (ex.Message, "#A4");
 693 #endif
 694                         }
 695
 696                         try {
 697                                 o [-1] = new OracleParameter ();
 698                                 Assert.Fail ("#B1");
 699                         } catch (IndexOutOfRangeException ex) {
 700 #if NET_2_0
 701                                 // Invalid index -1 for this OracleParameterCollection
 702                                 // with Count=1
 703                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
 704                                 Assert.IsNull (ex.InnerException, "#B3");
 705                                 Assert.IsNotNull (ex.Message, "#B4");
 706                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
 707 #else
 708                                 // Index -1 outside the scope of the parameter array
 709                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
 710                                 Assert.IsNull (ex.InnerException, "#B3");
 711                                 Assert.IsNotNull (ex.Message, "#B4");
 712 #endif
 713                         }
 714
 715                         try {
 716                                 object value = o [1];
 717                                 Assert.Fail ("#C1:" + value);
 718                         } catch (IndexOutOfRangeException ex) {
 719 #if NET_2_0
 720                                 // Invalid index 1 for this OracleParameterCollection
 721                                 // with Count=1
 722                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#C2");
 723                                 Assert.IsNull (ex.InnerException, "#C3");
 724                                 Assert.IsNotNull (ex.Message, "#C4");
 725                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#C5");
 726 #else
 727                                 // Index 1 outside the scope of the parameter array
 728                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#C2");
 729                                 Assert.IsNull (ex.InnerException, "#C3");
 730                                 Assert.IsNotNull (ex.Message, "#C4");
 731 #endif
 732                         }
 733
 734                         try {
 735                                 object value = o [-1];
 736                                 Assert.Fail ("#D1");
 737                         } catch (IndexOutOfRangeException ex) {
 738 #if NET_2_0
 739                                 // Invalid index -1 for this OracleParameterCollection
 740                                 // with Count=1
 741                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#D2");
 742                                 Assert.IsNull (ex.InnerException, "#D3");
 743                                 Assert.IsNotNull (ex.Message, "#D4");
 744                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#D5");
 745 #else
 746                                 // Index -1 outside the scope of the parameter array
 747                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#D2");
 748                                 Assert.IsNull (ex.InnerException, "#D3");
 749                                 Assert.IsNotNull (ex.Message, "#D4");
 750 #endif
 751                         }
 752                 }
 753
 754                 [Test] // OracleParameter this [Int32]
 755                 public void Indexer1_Value_Null ()
 756                 {
 757                         OracleParameter param = new OracleParameter ("ParamI", 1);
 758                         o.Add (param);
 759
 760                         try {
 761                                 o [0] = null;
 762                                 Assert.Fail ("#1");
 763                         } catch (ArgumentNullException ex) {
 764 #if NET_2_0
 765                                 // The OracleParameterCollection only accepts
 766                                 // non-null OracleParameter type objects
 767                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 768                                 Assert.IsNull (ex.InnerException, "#3");
 769                                 Assert.IsNotNull (ex.Message, "#4");
 770                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
 771                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
 772                                 Assert.AreEqual ("value", ex.ParamName, "#7");
 773 #else
 774                                 // Value cannot be null
 775                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 776                                 Assert.IsNull (ex.InnerException, "#3");
 777                                 Assert.IsNotNull (ex.Message, "#4");
 778                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
 779                                 Assert.IsFalse (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
 780                                 Assert.AreEqual ("value", ex.ParamName, "#7");
 781 #endif
 782                         }
 783                 }
 784
 785                 [Test] // OracleParameter this [Int32]
 786                 public void Indexer1_Value_Owned ()
 787                 {
 788                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 789                         OracleParameter paramB = new OracleParameter ("paramI", 2);
 790                         OracleParameter paramC = new OracleParameter ("Parami", 3);
 791
 792                         o.Add (paramA);
 793                         o.Add (paramB);
 794
 795                         // attempt to add same OracleParameter to collection twice
 796                         try {
 797                                 o [1] = paramA;
 798                                 Assert.Fail ("#A1");
 799                         } catch (ArgumentException ex) {
 800                                 // The OracleParameter is already contained by
 801                                 // another OracleParameterCollection
 802                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 803                                 Assert.IsNull (ex.InnerException, "#A3");
 804                                 Assert.IsNotNull (ex.Message, "#A4");
 805                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 806                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
 807                                 Assert.IsNull (ex.ParamName, "#A7");
 808                         }
 809
 810                         OracleParameterCollection o2 = new OracleParameterCollection ();
 811                         o2.Add (paramC);
 812
 813                         // attempt to add OracleParameter to another collection
 814                         try {
 815                                 o2 [0] = paramA;
 816                                 Assert.Fail ("#B1");
 817                         } catch (ArgumentException ex) {
 818                                 // The OracleParameter is already contained by
 819                                 // another OracleParameterCollection
 820                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 821                                 Assert.IsNull (ex.InnerException, "#B3");
 822                                 Assert.IsNotNull (ex.Message, "#B4");
 823                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
 824                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B6");
 825                                 Assert.IsNull (ex.ParamName, "#B7");
 826                         }
 827
 828                         o.Remove (paramA);
 829                         o [0] = paramA;
 830                         o.Remove (paramA);
 831                         o2 [0] = paramA;
 832                 }
 833
 834                 [Test] // OracleParameter this [String]
 835                 public void Indexer2 ()
 836                 {
 837                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 838                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 839                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 840                         OracleParameter paramD = new OracleParameter ("parami", 4);
 841                         OracleParameter paramE = new OracleParameter ("ParamI", 5);
 842                         OracleParameter paramF = new OracleParameter ("Parami", 6);
 843                         OracleParameter paramG = new OracleParameter ("ParamG", 7);
 844                         OracleParameter paramH = new OracleParameter ("ParamH", 8);
 845
 846                         o.Add (paramA);
 847                         o.Add (paramB);
 848                         o.Add (paramC);
 849                         o.Add (paramD);
 850                         o.Add (paramE);
 851                         o.Add (paramF);
 852
 853                         Assert.AreSame (paramA, o ["ParamI"], "#A1");
 854                         Assert.AreSame (paramB, o ["Parami"], "#A2");
 855 #if NET_2_0
 856                         Assert.AreSame (paramC, o ["paramI"], "#A3");
 857                         Assert.AreSame (paramD, o ["parami"], "#A4");
 858 #else
 859                         Assert.AreSame (paramA, o ["paramI"], "#A3");
 860                         Assert.AreSame (paramB, o ["parami"], "#A4");
 861 #endif
 862                         Assert.AreEqual (0, o.IndexOf (paramA), "#A5");
 863                         Assert.AreEqual (1, o.IndexOf (paramB), "#A6");
 864                         Assert.AreEqual (2, o.IndexOf (paramC), "#A7");
 865                         Assert.AreEqual (3, o.IndexOf (paramD), "#A8");
 866                         Assert.AreEqual (4, o.IndexOf (paramE), "#A9");
 867                         Assert.AreEqual (5, o.IndexOf (paramF), "#A10");
 868                         Assert.AreEqual (-1, o.IndexOf (paramG), "#A11");
 869                         Assert.AreEqual (-1, o.IndexOf (paramH), "#A12");
 870
 871                         o ["ParamI"] = paramG;
 872 #if NET_2_0
 873                         Assert.AreSame (paramE, o ["ParamI"], "#B1");
 874 #else
 875                         Assert.AreSame (paramC, o ["ParamI"], "#B1");
 876 #endif
 877                         Assert.AreSame (paramB, o ["Parami"], "#B2");
 878                         Assert.AreSame (paramC, o ["paramI"], "#B3");
 879 #if NET_2_0
 880                         Assert.AreSame (paramD, o ["parami"], "#B4");
 881 #else
 882                         Assert.AreSame (paramB, o ["parami"], "#B4");
 883 #endif
 884                         Assert.AreSame (paramG, o ["paramG"], "#B5");
 885                         Assert.AreEqual (-1, o.IndexOf (paramA), "#B6");
 886                         Assert.AreEqual (1, o.IndexOf (paramB), "#B7");
 887                         Assert.AreEqual (2, o.IndexOf (paramC), "#B8");
 888                         Assert.AreEqual (3, o.IndexOf (paramD), "#B9");
 889                         Assert.AreEqual (4, o.IndexOf (paramE), "#B10");
 890                         Assert.AreEqual (5, o.IndexOf (paramF), "#B11");
 891                         Assert.AreEqual (0, o.IndexOf (paramG), "#B12");
 892                         Assert.AreEqual (-1, o.IndexOf (paramH), "#B13");
 893
 894                         o ["ParamI"] = paramH;
 895 #if NET_2_0
 896                         Assert.AreSame (paramC, o ["ParamI"], "#C1");
 897 #else
 898                         Assert.AreSame (paramE, o ["ParamI"], "#C1");
 899 #endif
 900                         Assert.AreSame (paramB, o ["Parami"], "#C2");
 901 #if NET_2_0
 902                         Assert.AreSame (paramC, o ["paramI"], "#C3");
 903                         Assert.AreSame (paramD, o ["parami"], "#C4");
 904 #else
 905                         Assert.AreSame (paramE, o ["paramI"], "#C3");
 906                         Assert.AreSame (paramB, o ["parami"], "#C4");
 907 #endif
 908                         Assert.AreSame (paramG, o ["paramG"], "#C5");
 909                         Assert.AreSame (paramH, o ["paramH"], "#C6");
 910                         Assert.AreEqual (-1, o.IndexOf (paramA), "#C6");
 911                         Assert.AreEqual (1, o.IndexOf (paramB), "#C7");
 912 #if NET_2_0
 913                         Assert.AreEqual (2, o.IndexOf (paramC), "#C8");
 914 #else
 915                         Assert.AreEqual (-1, o.IndexOf (paramC), "#C8");
 916 #endif
 917                         Assert.AreEqual (3, o.IndexOf (paramD), "#C9");
 918 #if NET_2_0
 919                         Assert.AreEqual (-1, o.IndexOf (paramE), "#C10");
 920 #else
 921                         Assert.AreEqual (4, o.IndexOf (paramE), "#C10");
 922 #endif
 923                         Assert.AreEqual (5, o.IndexOf (paramF), "#C11");
 924                         Assert.AreEqual (0, o.IndexOf (paramG), "#C12");
 925 #if NET_2_0
 926                         Assert.AreEqual (4, o.IndexOf (paramH), "#C13");
 927 #else
 928                         Assert.AreEqual (2, o.IndexOf (paramH), "#C13");
 929 #endif
 930
 931                         o ["paramG"] = paramA;
 932                         Assert.AreSame (paramA, o ["ParamI"], "#D1");
 933                         Assert.AreSame (paramB, o ["Parami"], "#D2");
 934 #if NET_2_0
 935                         Assert.AreSame (paramC, o ["paramI"], "#D3");
 936                         Assert.AreSame (paramD, o ["parami"], "#D4");
 937 #else
 938                         Assert.AreSame (paramA, o ["paramI"], "#D3");
 939                         Assert.AreSame (paramB, o ["parami"], "#D4");
 940 #endif
 941                         Assert.AreSame (paramH, o ["paramH"], "#D5");
 942                         Assert.AreEqual (0, o.IndexOf (paramA), "#D6");
 943                         Assert.AreEqual (1, o.IndexOf (paramB), "#D7");
 944 #if NET_2_0
 945                         Assert.AreEqual (2, o.IndexOf (paramC), "#D8");
 946 #else
 947                         Assert.AreEqual (-1, o.IndexOf (paramC), "#D8");
 948 #endif
 949                         Assert.AreEqual (3, o.IndexOf (paramD), "#D9");
 950 #if NET_2_0
 951                         Assert.AreEqual (-1, o.IndexOf (paramE), "#D10");
 952 #else
 953                         Assert.AreEqual (4, o.IndexOf (paramE), "#D10");
 954 #endif
 955                         Assert.AreEqual (5, o.IndexOf (paramF), "#D11");
 956                         Assert.AreEqual (-1, o.IndexOf (paramG), "#D12");
 957 #if NET_2_0
 958                         Assert.AreEqual (4, o.IndexOf (paramH), "#D13");
 959 #else
 960                         Assert.AreEqual (2, o.IndexOf (paramH), "#D13");
 961 #endif
 962
 963                         o ["ParamI"] = paramA;
 964                         Assert.AreSame (paramA, o ["ParamI"], "#E1");
 965                         Assert.AreSame (paramB, o ["Parami"], "#E2");
 966 #if NET_2_0
 967                         Assert.AreSame (paramC, o ["paramI"], "#E3");
 968                         Assert.AreSame (paramD, o ["parami"], "#E4");
 969 #else
 970                         Assert.AreSame (paramA, o ["paramI"], "#E3");
 971                         Assert.AreSame (paramB, o ["parami"], "#E4");
 972 #endif
 973                         Assert.AreSame (paramH, o ["paramH"], "#E5");
 974                         Assert.AreEqual (0, o.IndexOf (paramA), "#E6");
 975                         Assert.AreEqual (1, o.IndexOf (paramB), "#E7");
 976 #if NET_2_0
 977                         Assert.AreEqual (2, o.IndexOf (paramC), "#E8");
 978 #else
 979                         Assert.AreEqual (-1, o.IndexOf (paramC), "#E8");
 980 #endif
 981                         Assert.AreEqual (3, o.IndexOf (paramD), "#E9");
 982 #if NET_2_0
 983                         Assert.AreEqual (-1, o.IndexOf (paramE), "#E10");
 984 #else
 985                         Assert.AreEqual (4, o.IndexOf (paramE), "#E10");
 986 #endif
 987                         Assert.AreEqual (5, o.IndexOf (paramF), "#E11");
 988                         Assert.AreEqual (-1, o.IndexOf (paramG), "#E12");
 989 #if NET_2_0
 990                         Assert.AreEqual (4, o.IndexOf (paramH), "#E13");
 991 #else
 992                         Assert.AreEqual (2, o.IndexOf (paramH), "#E13");
 993 #endif
 994
 995                         o ["paramI"] = paramC;
 996 #if NET_2_0
 997                         Assert.AreSame (paramA, o ["ParamI"], "#F1");
 998 #else
 999                         Assert.AreSame (paramC, o ["ParamI"], "#F1");
1000 #endif
1001                         Assert.AreSame (paramB, o ["Parami"], "#F2");
1002                         Assert.AreSame (paramC, o ["paramI"], "#F3");
1003 #if NET_2_0
1004                         Assert.AreSame (paramD, o ["parami"], "#F4");
1005 #else
1006                         Assert.AreSame (paramB, o ["parami"], "#F4");
1007 #endif
1008                         Assert.AreSame (paramH, o ["paramH"], "#F5");
1009 #if NET_2_0
1010                         Assert.AreEqual (0, o.IndexOf (paramA), "#F6");
1011 #else
1012                         Assert.AreEqual (-1, o.IndexOf (paramA), "#F6");
1013 #endif
1014                         Assert.AreEqual (1, o.IndexOf (paramB), "#F7");
1015 #if NET_2_0
1016                         Assert.AreEqual (2, o.IndexOf (paramC), "#F8");
1017 #else
1018                         Assert.AreEqual (0, o.IndexOf (paramC), "#F8");
1019 #endif
1020                         Assert.AreEqual (3, o.IndexOf (paramD), "#F9");
1021 #if NET_2_0
1022                         Assert.AreEqual (-1, o.IndexOf (paramE), "#F10");
1023 #else
1024                         Assert.AreEqual (4, o.IndexOf (paramE), "#F10");
1025 #endif
1026                         Assert.AreEqual (5, o.IndexOf (paramF), "#F11");
1027                         Assert.AreEqual (-1, o.IndexOf (paramG), "#F12");
1028 #if NET_2_0
1029                         Assert.AreEqual (4, o.IndexOf (paramH), "#F13");
1030 #else
1031                         Assert.AreEqual (2, o.IndexOf (paramH), "#F13");
1032 #endif
1033
1034                         OracleParameterCollection o2 = new OracleParameterCollection ();
1035 #if NET_2_0
1036                         o2.Add (paramE);
1037 #else
1038                         o2.Add (paramA);
1039 #endif
1040                 }
1041
1042                 [Test] // OracleParameter this [String]
1043                 public void Indexer2_ParameterName_NotFound ()
1044                 {
1045                         OracleParameter param = new OracleParameter ("ParamI", 1);
1046                         o.Add (param);
1047
1048                         try {
1049                                 o ["NotFound"] = new OracleParameter ();
1050                                 Assert.Fail ("#A1");
1051                         } catch (IndexOutOfRangeException ex) {
1052 #if NET_2_0
1053                                 // Invalid index -1 for this OracleParameterCollection
1054                                 // with Count=1
1055                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
1056                                 Assert.IsNull (ex.InnerException, "#A3");
1057                                 Assert.IsNotNull (ex.Message, "#A4");
1058                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1059                                 Assert.IsFalse (ex.Message.IndexOf ("'NotFound'") != -1, "#A6");
1060 #else
1061                                 // Parameter 'NotFound' not found
1062                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
1063                                 Assert.IsNull (ex.InnerException, "#A3");
1064                                 Assert.IsNotNull (ex.Message, "#A4");
1065                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1066                                 Assert.IsTrue (ex.Message.IndexOf ("'NotFound'") != -1, "#A6");
1067 #endif
1068                         }
1069
1070                         try {
1071                                 o [(string) null] = new OracleParameter ();
1072                                 Assert.Fail ("#B1");
1073                         } catch (IndexOutOfRangeException ex) {
1074 #if NET_2_0
1075                                 // Invalid index -1 for this OracleParameterCollection
1076                                 // with Count=1
1077                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
1078                                 Assert.IsNull (ex.InnerException, "#B3");
1079                                 Assert.IsNotNull (ex.Message, "#B4");
1080                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1081                                 Assert.IsFalse (ex.Message.IndexOf ("''") != -1, "#B6");
1082 #else
1083                                 // Parameter '' not found
1084                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
1085                                 Assert.IsNull (ex.InnerException, "#B3");
1086                                 Assert.IsNotNull (ex.Message, "#B4");
1087                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1088                                 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#B6");
1089 #endif
1090                         }
1091
1092                         try {
1093                                 object value = o ["NotFound"];
1094                                 Assert.Fail ("#C1:" + value);
1095                         } catch (IndexOutOfRangeException ex) {
1096 #if NET_2_0
1097                                 // Invalid index -1 for this OracleParameterCollection
1098                                 // with Count=1
1099                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#C2");
1100                                 Assert.IsNull (ex.InnerException, "#C3");
1101                                 Assert.IsNotNull (ex.Message, "#C4");
1102                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#C5");
1103                                 Assert.IsFalse (ex.Message.IndexOf ("'NotFound'") != -1, "#C6");
1104 #else
1105                                 // Parameter 'NotFound' not found
1106                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#C2");
1107                                 Assert.IsNull (ex.InnerException, "#C3");
1108                                 Assert.IsNotNull (ex.Message, "#C4");
1109                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#C5");
1110                                 Assert.IsTrue (ex.Message.IndexOf ("'NotFound'") != -1, "#C6");
1111 #endif
1112                         }
1113
1114                         try {
1115                                 object value = o [(string) null];
1116                                 Assert.Fail ("#D1:" + value);
1117                         } catch (IndexOutOfRangeException ex) {
1118 #if NET_2_0
1119                                 // Invalid index -1 for this OracleParameterCollection
1120                                 // with Count=1
1121                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#D2");
1122                                 Assert.IsNull (ex.InnerException, "#D3");
1123                                 Assert.IsNotNull (ex.Message, "#D4");
1124                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#D5");
1125                                 Assert.IsFalse (ex.Message.IndexOf ("''") != -1, "#D6");
1126 #else
1127                                 // Parameter 'NotFound' not found
1128                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#D2");
1129                                 Assert.IsNull (ex.InnerException, "#D3");
1130                                 Assert.IsNotNull (ex.Message, "#D4");
1131                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#D5");
1132                                 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#D6");
1133 #endif
1134                         }
1135                 }
1136
1137                 [Test] // OracleParameter this [String]
1138                 public void Indexer2_Value_Null ()
1139                 {
1140                         OracleParameter param = new OracleParameter ("ParamI", 1);
1141                         o.Add (param);
1142
1143                         try {
1144                                 o ["ParamI"] = null;
1145                                 Assert.Fail ("#1");
1146                         } catch (ArgumentNullException ex) {
1147 #if NET_2_0
1148                                 // The OracleParameterCollection only accepts
1149                                 // non-null OracleParameter type objects
1150                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1151                                 Assert.IsNull (ex.InnerException, "#3");
1152                                 Assert.IsNotNull (ex.Message, "#4");
1153                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
1154                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
1155                                 Assert.AreEqual ("value", ex.ParamName, "#7");
1156 #else
1157                                 // Value cannot be null
1158                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1159                                 Assert.IsNull (ex.InnerException, "#3");
1160                                 Assert.IsNotNull (ex.Message, "#4");
1161                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
1162                                 Assert.IsFalse (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
1163                                 Assert.AreEqual ("value", ex.ParamName, "#7");
1164 #endif
1165                         }
1166                 }
1167
1168                 [Test] // OracleParameter this [String]
1169                 public void Indexer2_Value_Owned ()
1170                 {
1171                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1172                         OracleParameter paramB = new OracleParameter ("paramI", 2);
1173                         OracleParameter paramC = new OracleParameter ("Parami", 3);
1174
1175                         o.Add (paramA);
1176                         o.Add (paramB);
1177 #if !NET_2_0
1178                         o.Add (paramC);
1179                         o ["paramI"] = paramA;
1180 #endif
1181
1182                         // attempt to add same OracleParameter to collection twice
1183                         try {
1184 #if NET_2_0
1185                                 o ["paramI"] = paramA;
1186 #else
1187                                 o ["Parami"] = paramA;
1188 #endif
1189                                 Assert.Fail ("#A1");
1190                         } catch (ArgumentException ex) {
1191                                 // The OracleParameter is already contained by
1192                                 // another OracleParameterCollection
1193                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1194                                 Assert.IsNull (ex.InnerException, "#A3");
1195                                 Assert.IsNotNull (ex.Message, "#A4");
1196                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1197                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
1198                                 Assert.IsNull (ex.ParamName, "#A7");
1199                         }
1200
1201                         OracleParameterCollection o2 = new OracleParameterCollection ();
1202                         o2.Add (paramC);
1203
1204                         // attempt to add OracleParameter to another collection
1205                         try {
1206                                 o2 ["Parami"] = paramA;
1207                                 Assert.Fail ("#B1");
1208                         } catch (ArgumentException ex) {
1209                                 // The OracleParameter is already contained by
1210                                 // another OracleParameterCollection
1211                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1212                                 Assert.IsNull (ex.InnerException, "#B3");
1213                                 Assert.IsNotNull (ex.Message, "#B4");
1214                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1215                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B6");
1216                                 Assert.IsNull (ex.ParamName, "#B7");
1217                         }
1218
1219                         o.Remove (paramA);
1220                         o ["paramI"] = paramA;
1221                         o.Remove (paramA);
1222                         o2 ["Parami"] = paramA;
1223                 }
1224
1225                 [Test] // IndexOf (Object)
1226                 public void IndexOf1 ()
1227                 {
1228                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1229                         OracleParameter paramB = new OracleParameter ("Parami", 2);
1230                         OracleParameter paramC = new OracleParameter ("paramI", 3);
1231                         OracleParameter paramD = new OracleParameter ("parami", 4);
1232                         OracleParameter paramE = new OracleParameter ("ParamI", 1);
1233                         OracleParameter paramF = new OracleParameter ("Parami", 2);
1234
1235                         o.Add (paramA);
1236                         o.Add (paramB);
1237
1238                         Assert.AreEqual (1, o.IndexOf ((object) paramB), "#A1");
1239                         Assert.AreEqual (0, o.IndexOf ((object) paramA), "#A2");
1240                         Assert.AreEqual (-1, o.IndexOf ((object) paramD), "#A3");
1241                         Assert.AreEqual (-1, o.IndexOf ((object) paramC), "#A4");
1242                         Assert.AreEqual (-1, o.IndexOf ((object) paramF), "#A5");
1243                         Assert.AreEqual (-1, o.IndexOf ((object) paramE), "#A6");
1244                         Assert.AreEqual (-1, o.IndexOf ((object) null), "#A7");
1245
1246                         o.Add (paramC);
1247                         o.Add (paramD);
1248
1249                         Assert.AreEqual (1, o.IndexOf ((object) paramB), "#B1");
1250                         Assert.AreEqual (0, o.IndexOf ((object) paramA), "#B2");
1251                         Assert.AreEqual (3, o.IndexOf ((object) paramD), "#B3");
1252                         Assert.AreEqual (2, o.IndexOf ((object) paramC), "#B4");
1253                         Assert.AreEqual (-1, o.IndexOf ((object) paramF), "#B5");
1254                         Assert.AreEqual (-1, o.IndexOf ((object) paramE), "#B6");
1255                         Assert.AreEqual (-1, o.IndexOf ((object) null), "#B7");
1256                 }
1257
1258                 [Test] // IndexOf (Object)
1259                 public void IndexOf1_Value_InvalidType ()
1260                 {
1261                         try {
1262                                 o.IndexOf ((object) "ParamI");
1263                                 Assert.Fail ("#A1");
1264                         } catch (InvalidCastException ex) {
1265 #if NET_2_0
1266                                 // The OracleParameterCollection only accepts
1267                                 // non-null OracleParameter type objects, not
1268                                 // String objects
1269                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#A2");
1270                                 Assert.IsNull (ex.InnerException, "#A3");
1271                                 Assert.IsNotNull (ex.Message, "#A4");
1272                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1273                                 Assert.IsTrue (ex.Message.IndexOf (typeof (string).Name) != -1, "#A6");
1274                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#A7");
1275                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A8");
1276 #else
1277                                 // argument value must be of type System.Data.OracleClient.OracleParameter
1278                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#A2");
1279                                 Assert.IsNull (ex.InnerException, "#A3");
1280                                 Assert.IsNotNull (ex.Message, "#A4");
1281                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1282                                 Assert.IsFalse (ex.Message.IndexOf (typeof (string).Name) != -1, "#A6");
1283                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#A7");
1284                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A8");
1285 #endif
1286                         }
1287
1288                         try {
1289                                 o.IndexOf ((object) 5);
1290                                 Assert.Fail ("#B1");
1291                         } catch (InvalidCastException ex) {
1292 #if NET_2_0
1293                                 // The OracleParameterCollection only accepts
1294                                 // non-null OracleParameter type objects, not
1295                                 // Int32 objects
1296                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#B2");
1297                                 Assert.IsNull (ex.InnerException, "#B3");
1298                                 Assert.IsNotNull (ex.Message, "#B4");
1299                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1300                                 Assert.IsFalse (ex.Message.IndexOf (typeof (string).Name) != -1, "#B6");
1301                                 Assert.IsTrue (ex.Message.IndexOf (typeof (int).Name) != -1, "#B7");
1302                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B8");
1303 #else
1304                                 // argument value must be of type System.Data.OracleClient.OracleParameter
1305                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#B2");
1306                                 Assert.IsNull (ex.InnerException, "#B3");
1307                                 Assert.IsNotNull (ex.Message, "#B4");
1308                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1309                                 Assert.IsFalse (ex.Message.IndexOf (typeof (string).Name) != -1, "#B6");
1310                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#B7");
1311                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B8");
1312 #endif
1313                         }
1314                 }
1315
1316                 [Test] // IndexOf (OracleParameter)
1317                 public void IndexOf2 ()
1318                 {
1319                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1320                         OracleParameter paramB = new OracleParameter ("Parami", 2);
1321                         OracleParameter paramC = new OracleParameter ("paramI", 3);
1322                         OracleParameter paramD = new OracleParameter ("parami", 4);
1323                         OracleParameter paramE = new OracleParameter ("ParamI", 1);
1324                         OracleParameter paramF = new OracleParameter ("Parami", 2);
1325
1326                         o.Add (paramA);
1327                         o.Add (paramB);
1328
1329                         Assert.AreEqual (1, o.IndexOf (paramB), "#A1");
1330                         Assert.AreEqual (0, o.IndexOf (paramA), "#A2");
1331                         Assert.AreEqual (-1, o.IndexOf (paramD), "#A3");
1332                         Assert.AreEqual (-1, o.IndexOf (paramC), "#A4");
1333                         Assert.AreEqual (-1, o.IndexOf (paramF), "#A5");
1334                         Assert.AreEqual (-1, o.IndexOf (paramE), "#A6");
1335                         Assert.AreEqual (-1, o.IndexOf (null), "#A7");
1336
1337                         o.Add (paramC);
1338                         o.Add (paramD);
1339
1340                         Assert.AreEqual (1, o.IndexOf (paramB), "#B1");
1341                         Assert.AreEqual (0, o.IndexOf (paramA), "#B2");
1342                         Assert.AreEqual (3, o.IndexOf (paramD), "#B3");
1343                         Assert.AreEqual (2, o.IndexOf (paramC), "#B4");
1344                         Assert.AreEqual (-1, o.IndexOf (paramF), "#B5");
1345                         Assert.AreEqual (-1, o.IndexOf (paramE), "#B6");
1346                         Assert.AreEqual (-1, o.IndexOf (null), "#B7");
1347                 }
1348
1349                 [Test] // IndexOf (String)
1350                 public void IndexOf3 ()
1351                 {
1352                         OracleParameter paramA = new OracleParameter ("ParamI", 5);
1353                         OracleParameter paramB = new OracleParameter ("Parami", 4);
1354
1355                         o.Add (paramA);
1356                         o.Add (paramB);
1357
1358                         Assert.AreEqual (1, o.IndexOf ("Parami"), "#1");
1359                         Assert.AreEqual (0, o.IndexOf ("ParamI"), "#2");
1360                         Assert.AreEqual (0, o.IndexOf ("paramI"), "#3");
1361                         Assert.AreEqual (1, o.IndexOf ("parami"), "#4");
1362                         Assert.AreEqual (-1, o.IndexOf ("NotFound"), "#5");
1363                         Assert.AreEqual (-1, o.IndexOf (string.Empty), "#6");
1364                         Assert.AreEqual (-1, o.IndexOf ((string) null), "#7");
1365                 }
1366
1367                 [Test] // Insert (Int32, Object)
1368                 public void Insert1_Value_InvalidType ()
1369                 {
1370                         OracleParameter param = new OracleParameter ("ParamI", 1);
1371
1372                         o.Insert (0, (object) param);
1373
1374                         try {
1375                                 o.Insert (0, (object) "ParamI");
1376                                 Assert.Fail ("#A1");
1377                         } catch (InvalidCastException ex) {
1378 #if NET_2_0
1379                                 // The OracleParameterCollection only accepts
1380                                 // non-null OracleParameter type objects, not
1381                                 // String objects
1382                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#A2");
1383                                 Assert.IsNull (ex.InnerException, "#A3");
1384                                 Assert.IsNotNull (ex.Message, "#A4");
1385                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1386                                 Assert.IsTrue (ex.Message.IndexOf (typeof (string).Name) != -1, "#A6");
1387                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#A7");
1388                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A8");
1389 #else
1390                                 // argument value must be of type System.Data.OracleClient.OracleParameter
1391                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#A2");
1392                                 Assert.IsNull (ex.InnerException, "#A3");
1393                                 Assert.IsNotNull (ex.Message, "#A4");
1394                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1395                                 Assert.IsFalse (ex.Message.IndexOf (typeof (string).Name) != -1, "#A6");
1396                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#A7");
1397                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A8");
1398 #endif
1399                         }
1400
1401                         try {
1402                                 o.Insert (0, (object) 5);
1403                                 Assert.Fail ("#B1");
1404                         } catch (InvalidCastException ex) {
1405 #if NET_2_0
1406                                 // The OracleParameterCollection only accepts
1407                                 // non-null OracleParameter type objects, not
1408                                 // Int32 objects
1409                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#B2");
1410                                 Assert.IsNull (ex.InnerException, "#B3");
1411                                 Assert.IsNotNull (ex.Message, "#B4");
1412                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1413                                 Assert.IsFalse (ex.Message.IndexOf (typeof (string).Name) != -1, "#B6");
1414                                 Assert.IsTrue (ex.Message.IndexOf (typeof (int).Name) != -1, "#B7");
1415                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B8");
1416 #else
1417                                 // argument value must be of type System.Data.OracleClient.OracleParameter
1418                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#B2");
1419                                 Assert.IsNull (ex.InnerException, "#B3");
1420                                 Assert.IsNotNull (ex.Message, "#B4");
1421                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1422                                 Assert.IsFalse (ex.Message.IndexOf (typeof (string).Name) != -1, "#B6");
1423                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#B7");
1424                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B8");
1425 #endif
1426                         }
1427                 }
1428
1429                 [Test] // Insert (Int32, Object)
1430                 public void Insert1_Value_Null ()
1431                 {
1432                         try {
1433                                 o.Insert (0, (object) null);
1434                                 Assert.Fail ("#1");
1435                         } catch (ArgumentNullException ex) {
1436 #if NET_2_0
1437                                 // The OracleParameterCollection only accepts
1438                                 // non-null OracleParameter type objects
1439                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1440                                 Assert.IsNull (ex.InnerException, "#3");
1441                                 Assert.IsNotNull (ex.Message, "#4");
1442                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
1443                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
1444                                 Assert.AreEqual ("value", ex.ParamName, "#7");
1445 #else
1446                                 // Value cannot be null
1447                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1448                                 Assert.IsNull (ex.InnerException, "#3");
1449                                 Assert.IsNotNull (ex.Message, "#4");
1450                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
1451                                 Assert.IsFalse (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
1452                                 Assert.AreEqual ("value", ex.ParamName, "#7");
1453 #endif
1454                         }
1455                 }
1456
1457                 [Test] // Insert (Int32, Object)
1458                 public void Insert1_Value_Owned ()
1459                 {
1460                         OracleParameter param = new OracleParameter ("ParamI", 1);
1461
1462                         o.Insert (0, (object) param);
1463
1464                         // attempt to add same OracleParameter to collection twice
1465                         try {
1466                                 o.Insert (1, (object) param);
1467                                 Assert.Fail ("#A1");
1468                         } catch (ArgumentException ex) {
1469                                 // The OracleParameter is already contained by
1470                                 // another OracleParameterCollection
1471                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1472                                 Assert.IsNull (ex.InnerException, "#A3");
1473                                 Assert.IsNotNull (ex.Message, "#A4");
1474                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1475                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
1476                                 Assert.IsNull (ex.ParamName, "#A7");
1477                         }
1478
1479                         OracleParameterCollection o2 = new OracleParameterCollection ();
1480
1481                         // attempt to add OracleParameter to another collection
1482                         try {
1483                                 o2.Insert (0, (object) param);
1484                                 Assert.Fail ("#B1");
1485                         } catch (ArgumentException ex) {
1486                                 // The OracleParameter is already contained by
1487                                 // another OracleParameterCollection
1488                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1489                                 Assert.IsNull (ex.InnerException, "#B3");
1490                                 Assert.IsNotNull (ex.Message, "#B4");
1491                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1492                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B6");
1493                                 Assert.IsNull (ex.ParamName, "#B7");
1494                         }
1495
1496                         o.Remove (param);
1497                         o.Insert (0, (object) param);
1498                         o.Remove (param);
1499                         o2.Insert (0, (object) param);
1500                 }
1501
1502                 [Test] // Insert (Int32, OracleParameter)
1503                 public void Insert2_Value_Null ()
1504                 {
1505                         try {
1506                                 o.Insert (0, (OracleParameter) null);
1507                                 Assert.Fail ("#1");
1508                         } catch (ArgumentNullException ex) {
1509 #if NET_2_0
1510                                 // The OracleParameterCollection only accepts
1511                                 // non-null OracleParameter type objects
1512                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1513                                 Assert.IsNull (ex.InnerException, "#3");
1514                                 Assert.IsNotNull (ex.Message, "#4");
1515                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
1516                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
1517                                 Assert.AreEqual ("value", ex.ParamName, "#7");
1518 #else
1519                                 // Value cannot be null
1520                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1521                                 Assert.IsNull (ex.InnerException, "#3");
1522                                 Assert.IsNotNull (ex.Message, "#4");
1523                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
1524                                 Assert.IsFalse (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
1525                                 Assert.AreEqual ("value", ex.ParamName, "#7");
1526 #endif
1527                         }
1528                 }
1529
1530                 [Test] // Insert (Int32, OracleParameter)
1531                 public void Insert2_Value_Owned ()
1532                 {
1533                         OracleParameter param = new OracleParameter ("ParamI", 1);
1534
1535                         o.Insert (0, param);
1536
1537                         // attempt to add same OracleParameter to collection twice
1538                         try {
1539                                 o.Insert (1, param);
1540                                 Assert.Fail ("#A1");
1541                         } catch (ArgumentException ex) {
1542                                 // The OracleParameter is already contained by
1543                                 // another OracleParameterCollection
1544                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1545                                 Assert.IsNull (ex.InnerException, "#A3");
1546                                 Assert.IsNotNull (ex.Message, "#A4");
1547                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1548                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
1549                                 Assert.IsNull (ex.ParamName, "#A7");
1550                         }
1551
1552                         OracleParameterCollection o2 = new OracleParameterCollection ();
1553
1554                         // attempt to add OracleParameter to another collection
1555                         try {
1556                                 o2.Insert (0, param);
1557                                 Assert.Fail ("#B1");
1558                         } catch (ArgumentException ex) {
1559                                 // The OracleParameter is already contained by
1560                                 // another OracleParameterCollection
1561                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1562                                 Assert.IsNull (ex.InnerException, "#B3");
1563                                 Assert.IsNotNull (ex.Message, "#B4");
1564                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1565                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B6");
1566                                 Assert.IsNull (ex.ParamName, "#B7");
1567                         }
1568
1569                         o.Remove (param);
1570                         o.Insert (0, param);
1571                         o.Remove (param);
1572                         o2.Insert (0, param);
1573                 }
1574
1575                 [Test] // Remove (Object)
1576                 public void Remove1 ()
1577                 {
1578                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1579                         OracleParameter paramB = new OracleParameter ("Parami", 2);
1580                         OracleParameter paramC = new OracleParameter ("paramI", 3);
1581
1582                         o.Add (paramA);
1583                         o.Add (paramB);
1584                         o.Remove ((object) paramA);
1585
1586                         Assert.AreEqual (-1, o.IndexOf (paramA), "#A1");
1587                         Assert.AreEqual (0, o.IndexOf (paramB), "#A2");
1588
1589                         o.Add (paramA);
1590
1591                         Assert.AreEqual (1, o.IndexOf (paramA), "#B1");
1592                         Assert.AreEqual (0, o.IndexOf (paramB), "#B2");
1593
1594                         o.Remove ((object) paramB);
1595
1596                         Assert.AreEqual (0, o.IndexOf (paramA), "#C1");
1597                         Assert.AreEqual (-1, o.IndexOf (paramB), "#C2");
1598
1599                         OracleParameterCollection o2 = new OracleParameterCollection ();
1600                         o2.Add (paramB);
1601                 }
1602
1603                 [Test] // Remove (Object)
1604                 public void Remove1_Value_InvalidType ()
1605                 {
1606                         try {
1607                                 o.Remove ((object) "ParamI");
1608                                 Assert.Fail ("#A1");
1609                         } catch (InvalidCastException ex) {
1610 #if NET_2_0
1611                                 // The OracleParameterCollection only accepts
1612                                 // non-null OracleParameter type objects, not
1613                                 // String objects
1614                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#A2");
1615                                 Assert.IsNull (ex.InnerException, "#A3");
1616                                 Assert.IsNotNull (ex.Message, "#A4");
1617                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1618                                 Assert.IsTrue (ex.Message.IndexOf (typeof (string).Name) != -1, "#A6");
1619                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#A7");
1620                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A8");
1621 #else
1622                                 // argument value must be of type System.Data.OracleClient.OracleParameter
1623                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#A2");
1624                                 Assert.IsNull (ex.InnerException, "#A3");
1625                                 Assert.IsNotNull (ex.Message, "#A4");
1626                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1627                                 Assert.IsFalse (ex.Message.IndexOf (typeof (string).Name) != -1, "#A6");
1628                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#A7");
1629                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A8");
1630 #endif
1631                         }
1632
1633                         try {
1634                                 o.Remove ((object) 5);
1635                                 Assert.Fail ("#B1");
1636                         } catch (InvalidCastException ex) {
1637 #if NET_2_0
1638                                 // The OracleParameterCollection only accepts
1639                                 // non-null OracleParameter type objects, not
1640                                 // Int32 objects
1641                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#B2");
1642                                 Assert.IsNull (ex.InnerException, "#B3");
1643                                 Assert.IsNotNull (ex.Message, "#B4");
1644                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1645                                 Assert.IsFalse (ex.Message.IndexOf (typeof (string).Name) != -1, "#B6");
1646                                 Assert.IsTrue (ex.Message.IndexOf (typeof (int).Name) != -1, "#B7");
1647                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B8");
1648 #else
1649                                 // argument value must be of type System.Data.OracleClient.OracleParameter
1650                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#B2");
1651                                 Assert.IsNull (ex.InnerException, "#B3");
1652                                 Assert.IsNotNull (ex.Message, "#B4");
1653                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1654                                 Assert.IsFalse (ex.Message.IndexOf (typeof (string).Name) != -1, "#B6");
1655                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#B7");
1656                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B8");
1657 #endif
1658                         }
1659                 }
1660
1661                 [Test] // Remove (Object)
1662                 public void Remove1_Value_NotOwned ()
1663                 {
1664                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1665
1666                         try {
1667                                 o.Remove ((object) paramA);
1668                                 Assert.Fail ("#1");
1669                         } catch (ArgumentException ex) {
1670 #if NET_2_0
1671                                 // Attempted to remove an OracleParameter that
1672                                 // is not contained by this OracleParameterCollection
1673                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1674                                 Assert.IsNull (ex.InnerException, "#B3");
1675                                 Assert.IsNotNull (ex.Message, "#B4");
1676                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1677                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B6");
1678                                 Assert.IsNull (ex.ParamName, "#B7");
1679 #else
1680                                 // Parameter not found
1681                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1682                                 Assert.IsNull (ex.InnerException, "#B3");
1683                                 Assert.IsNotNull (ex.Message, "#B4");
1684                                 Assert.IsNull (ex.ParamName, "#B5");
1685 #endif
1686                         }
1687                 }
1688
1689                 [Test] // Remove (Object)
1690                 public void Remove1_Value_Null ()
1691                 {
1692                         try {
1693                                 o.Remove ((object) null);
1694                                 Assert.Fail ("#1");
1695                         } catch (ArgumentNullException ex) {
1696 #if NET_2_0
1697                                 // The OracleParameterCollection only accepts
1698                                 // non-null OracleParameter type objects
1699                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1700                                 Assert.IsNull (ex.InnerException, "#3");
1701                                 Assert.IsNotNull (ex.Message, "#4");
1702                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
1703                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
1704                                 Assert.AreEqual ("value", ex.ParamName, "#7");
1705 #else
1706                                 // Value cannot be null
1707                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1708                                 Assert.IsNull (ex.InnerException, "#3");
1709                                 Assert.IsNotNull (ex.Message, "#4");
1710                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
1711                                 Assert.IsFalse (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
1712                                 Assert.AreEqual ("value", ex.ParamName, "#7");
1713 #endif
1714                         }
1715                 }
1716
1717                 [Test] // Remove (OracleParameter)
1718                 public void Remove2 ()
1719                 {
1720                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1721                         OracleParameter paramB = new OracleParameter ("Parami", 2);
1722                         OracleParameter paramC = new OracleParameter ("paramI", 3);
1723
1724                         o.Add (paramA);
1725                         o.Add (paramB);
1726                         o.Remove (paramA);
1727
1728                         Assert.AreEqual (-1, o.IndexOf (paramA), "#A1");
1729                         Assert.AreEqual (0, o.IndexOf (paramB), "#A2");
1730
1731                         o.Add (paramA);
1732
1733                         Assert.AreEqual (1, o.IndexOf (paramA), "#B1");
1734                         Assert.AreEqual (0, o.IndexOf (paramB), "#B2");
1735
1736                         o.Remove (paramB);
1737
1738                         Assert.AreEqual (0, o.IndexOf (paramA), "#C1");
1739                         Assert.AreEqual (-1, o.IndexOf (paramB), "#C2");
1740
1741                         OracleParameterCollection o2 = new OracleParameterCollection ();
1742                         o2.Add (paramB);
1743                 }
1744
1745                 [Test] // Remove (OracleParameter)
1746                 public void Remove2_Value_NotOwned ()
1747                 {
1748                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1749
1750                         try {
1751                                 o.Remove (paramA);
1752                                 Assert.Fail ("#1");
1753                         } catch (ArgumentException ex) {
1754 #if NET_2_0
1755                                 // Attempted to remove an OracleParameter that
1756                                 // is not contained by this OracleParameterCollection
1757                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1758                                 Assert.IsNull (ex.InnerException, "#3");
1759                                 Assert.IsNotNull (ex.Message, "#4");
1760                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
1761                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
1762                                 Assert.IsNull (ex.ParamName, "#7");
1763 #else
1764                                 // Parameter not found
1765                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1766                                 Assert.IsNull (ex.InnerException, "#3");
1767                                 Assert.IsNotNull (ex.Message, "#4");
1768                                 Assert.IsNull (ex.ParamName, "#5");
1769 #endif
1770                         }
1771                 }
1772
1773                 [Test] // Remove (OracleParameter)
1774                 public void Remove2_Value_Null ()
1775                 {
1776                         try {
1777                                 o.Remove ((OracleParameter) null);
1778                                 Assert.Fail ("#1");
1779                         } catch (ArgumentNullException ex) {
1780 #if NET_2_0
1781                                 // The OracleParameterCollection only accepts
1782                                 // non-null OracleParameter type objects
1783                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1784                                 Assert.IsNull (ex.InnerException, "#3");
1785                                 Assert.IsNotNull (ex.Message, "#4");
1786                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
1787                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
1788                                 Assert.AreEqual ("value", ex.ParamName, "#7");
1789 #else
1790                                 // Value cannot be null
1791                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1792                                 Assert.IsNull (ex.InnerException, "#3");
1793                                 Assert.IsNotNull (ex.Message, "#4");
1794                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
1795                                 Assert.IsFalse (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
1796                                 Assert.AreEqual ("value", ex.ParamName, "#7");
1797 #endif
1798                         }
1799                 }
1800
1801                 [Test] // RemoveAt (Int32)
1802                 public void RemoveAt1 ()
1803                 {
1804                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1805                         OracleParameter paramB = new OracleParameter ("Parami", 2);
1806                         OracleParameter paramC = new OracleParameter ("paramI", 3);
1807
1808                         o.Add (paramA);
1809                         o.Add (paramB);
1810                         o.Add (paramC);
1811
1812                         o.RemoveAt (2);
1813
1814                         Assert.AreEqual (0, o.IndexOf (paramA), "#A1");
1815                         Assert.AreEqual (1, o.IndexOf (paramB), "#A2");
1816                         Assert.AreEqual (-1, o.IndexOf (paramC), "#A3");
1817
1818                         o.RemoveAt (0);
1819
1820                         Assert.AreEqual (-1, o.IndexOf (paramA), "#B1");
1821                         Assert.AreEqual (0, o.IndexOf (paramB), "#B2");
1822                         Assert.AreEqual (-1, o.IndexOf (paramC), "#B3");
1823
1824                         o.RemoveAt (0);
1825
1826                         Assert.AreEqual (-1, o.IndexOf (paramA), "#C1");
1827                         Assert.AreEqual (-1, o.IndexOf (paramB), "#C2");
1828                         Assert.AreEqual (-1, o.IndexOf (paramC), "#C3");
1829
1830                         o.Add (paramA);
1831                         o.Add (paramC);
1832
1833                         OracleParameterCollection o2 = new OracleParameterCollection ();
1834                         o2.Add (paramB);
1835                 }
1836
1837                 [Test] // RemoveAt (Int32)
1838                 public void RemoveAt1_Index_Invalid ()
1839                 {
1840                         try {
1841                                 o.RemoveAt (0);
1842                                 Assert.Fail ("#A1");
1843                         } catch (IndexOutOfRangeException ex) {
1844 #if NET_2_0
1845                                 // Invalid index 0 for this OracleParameterCollection
1846                                 // with Count=0
1847                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
1848                                 Assert.IsNull (ex.InnerException, "#A3");
1849                                 Assert.IsNotNull (ex.Message, "#A4");
1850                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1851 #else
1852                                 // Index 0 outside the scope of the parameter array
1853                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
1854                                 Assert.IsNull (ex.InnerException, "#A3");
1855                                 Assert.IsNotNull (ex.Message, "#A4");
1856 #endif
1857                         }
1858
1859                         try {
1860                                 o.RemoveAt (-1);
1861                                 Assert.Fail ("#B1");
1862                         } catch (IndexOutOfRangeException ex) {
1863 #if NET_2_0
1864                                 // Invalid index -1 for this OracleParameterCollection
1865                                 // with Count=0
1866                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
1867                                 Assert.IsNull (ex.InnerException, "#B3");
1868                                 Assert.IsNotNull (ex.Message, "#B4");
1869                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1870 #else
1871                                 // Index -1 outside the scope of the parameter array
1872                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
1873                                 Assert.IsNull (ex.InnerException, "#B3");
1874                                 Assert.IsNotNull (ex.Message, "#B4");
1875 #endif
1876                         }
1877                 }
1878
1879                 [Test] // RemoveAt (String)
1880                 public void RemoveAt2 ()
1881                 {
1882                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1883                         OracleParameter paramB = new OracleParameter ("Parami", 2);
1884                         OracleParameter paramC = new OracleParameter ("paramI", 3);
1885                         OracleParameter paramD = new OracleParameter ("parami", 4);
1886                         OracleParameter paramE = new OracleParameter ("parami", 5);
1887
1888                         o.Add (paramA);
1889                         o.Add (paramB);
1890                         o.Add (paramC);
1891                         o.Add (paramD);
1892                         o.Add (paramE);
1893
1894                         o.RemoveAt ("paramI");
1895
1896 #if NET_2_0
1897                         Assert.AreEqual (0, o.IndexOf (paramA), "#A1");
1898                         Assert.AreEqual (1, o.IndexOf (paramB), "#A2");
1899                         Assert.AreEqual (-1, o.IndexOf (paramC), "#A3");
1900 #else
1901                         Assert.AreEqual (-1, o.IndexOf (paramA), "#A1");
1902                         Assert.AreEqual (0, o.IndexOf (paramB), "#A2");
1903                         Assert.AreEqual (1, o.IndexOf (paramC), "#A3");
1904 #endif
1905                         Assert.AreEqual (2, o.IndexOf (paramD), "#A4");
1906                         Assert.AreEqual (3, o.IndexOf (paramE), "#A5");
1907
1908                         o.RemoveAt ("parami");
1909
1910 #if NET_2_0
1911                         Assert.AreEqual (0, o.IndexOf (paramA), "#B1");
1912                         Assert.AreEqual (1, o.IndexOf (paramB), "#B2");
1913                         Assert.AreEqual (-1, o.IndexOf (paramC), "#B3");
1914                         Assert.AreEqual (-1, o.IndexOf (paramD), "#B4");
1915 #else
1916                         Assert.AreEqual (-1, o.IndexOf (paramA), "#B1");
1917                         Assert.AreEqual (-1, o.IndexOf (paramB), "#B2");
1918                         Assert.AreEqual (0, o.IndexOf (paramC), "#B3");
1919                         Assert.AreEqual (1, o.IndexOf (paramD), "#B4");
1920 #endif
1921                         Assert.AreEqual (2, o.IndexOf (paramE), "#B5");
1922
1923                         o.RemoveAt ("Parami");
1924
1925 #if NET_2_0
1926                         Assert.AreEqual (0, o.IndexOf (paramA), "#C1");
1927 #else
1928                         Assert.AreEqual (-1, o.IndexOf (paramA), "#C1");
1929 #endif
1930                         Assert.AreEqual (-1, o.IndexOf (paramB), "#C2");
1931 #if NET_2_0
1932                         Assert.AreEqual (-1, o.IndexOf (paramC), "#C3");
1933 #else
1934                         Assert.AreEqual (0, o.IndexOf (paramC), "#C3");
1935 #endif
1936                         Assert.AreEqual (-1, o.IndexOf (paramD), "#C4");
1937                         Assert.AreEqual (1, o.IndexOf (paramE), "#C5");
1938
1939                         o.RemoveAt ("Parami");
1940
1941 #if NET_2_0
1942                         Assert.AreEqual (0, o.IndexOf (paramA), "#D1");
1943 #else
1944                         Assert.AreEqual (-1, o.IndexOf (paramA), "#D1");
1945 #endif
1946                         Assert.AreEqual (-1, o.IndexOf (paramB), "#D2");
1947 #if NET_2_0
1948                         Assert.AreEqual (-1, o.IndexOf (paramC), "#D3");
1949 #else
1950                         Assert.AreEqual (0, o.IndexOf (paramC), "#D3");
1951 #endif
1952                         Assert.AreEqual (-1, o.IndexOf (paramD), "#D4");
1953                         Assert.AreEqual (-1, o.IndexOf (paramE), "#D5");
1954
1955                         o.RemoveAt ("ParamI");
1956
1957                         Assert.AreEqual (-1, o.IndexOf (paramA), "#E1");
1958                         Assert.AreEqual (-1, o.IndexOf (paramB), "#E2");
1959                         Assert.AreEqual (-1, o.IndexOf (paramC), "#E3");
1960                         Assert.AreEqual (-1, o.IndexOf (paramD), "#E4");
1961                         Assert.AreEqual (-1, o.IndexOf (paramE), "#E5");
1962
1963                         o.Add (paramA);
1964                         o.Add (paramB);
1965                         o.Add (paramE);
1966
1967                         OracleParameterCollection o2 = new OracleParameterCollection ();
1968                         o2.Add (paramC);
1969                         o2.Add (paramD);
1970                 }
1971
1972                 [Test] // RemoveAt (String)
1973                 public void RemoveAt2_ParameterName_NotFound ()
1974                 {
1975                         o.Add (new OracleParameter ((string) null, 1));
1976                         o.Add (new OracleParameter (string.Empty, 1));
1977
1978                         try {
1979                                 o.RemoveAt ("NotFound");
1980                                 Assert.Fail ("#A1");
1981                         } catch (IndexOutOfRangeException ex) {
1982 #if NET_2_0
1983                                 // An OracleParameter with ParameterName 'NotFound'
1984                                 // is not contained by this OracleParameterCollection
1985                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
1986                                 Assert.IsNull (ex.InnerException, "#A3");
1987                                 Assert.IsNotNull (ex.Message, "#A4");
1988                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A5");
1989                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A6");
1990                                 Assert.IsTrue (ex.Message.IndexOf ("'NotFound'") != -1, "#A7");
1991 #else
1992                                 // Parameter 'NotFound' not found
1993                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
1994                                 Assert.IsNull (ex.InnerException, "#A3");
1995                                 Assert.IsNotNull (ex.Message, "#A4");
1996                                 Assert.IsFalse (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A5");
1997                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A6");
1998                                 Assert.IsTrue (ex.Message.IndexOf ("'NotFound'") != -1, "#A7");
1999 #endif
2000                         }
2001
2002                         try {
2003                                 o.RemoveAt ((string) null);
2004                                 Assert.Fail ("#B1");
2005                         } catch (IndexOutOfRangeException ex) {
2006 #if NET_2_0
2007                                 // An OracleParameter with ParameterName '' is
2008                                 // not contained by this OracleParameterCollection
2009                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
2010                                 Assert.IsNull (ex.InnerException, "#B3");
2011                                 Assert.IsNotNull (ex.Message, "#B4");
2012                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B5");
2013                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B6");
2014                                 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#B7");
2015 #else
2016                                 // Parameter '' not found
2017                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
2018                                 Assert.IsNull (ex.InnerException, "#B3");
2019                                 Assert.IsNotNull (ex.Message, "#B4");
2020                                 Assert.IsFalse (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B5");
2021                                 Assert.IsFalse (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B6");
2022                                 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#B7");
2023 #endif
2024                         }
2025                 }
2026         }
2027 }