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                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 124                                 Assert.IsTrue (ex.Message.IndexOf (typeof (string).Name) != -1, "#A6");
 125                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#A7");
 126                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A8");
 127                         }
 128
 129                         try {
 130                                 o.Add ((object) 5);
 131                                 Assert.Fail ("#B1");
 132                         } catch (InvalidCastException ex) {
 133                                 // The OracleParameterCollection only accepts
 134                                 // non-null OracleParameter type objects, not
 135                                 // String objects
 136                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#B2");
 137                                 Assert.IsNull (ex.InnerException, "#B3");
 138                                 Assert.IsNotNull (ex.Message, "#B4");
 139                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
 140                                 Assert.IsFalse (ex.Message.IndexOf (typeof (string).Name) != -1, "#B6");
 141                                 Assert.IsTrue (ex.Message.IndexOf (typeof (int).Name) != -1, "#B7");
 142                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B8");
 143                         }
 144                 }
 145
 146                 [Test] // Add (Object)
 147                 public void Add1_Value_Null ()
 148                 {
 149                         try {
 150                                 o.Add ((object) null);
 151                                 Assert.Fail ("#1");
 152                         } catch (ArgumentNullException ex) {
 153                                 // The OracleParameterCollection only accepts
 154                                 // non-null OracleParameter type objects
 155                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 156                                 Assert.IsNull (ex.InnerException, "#3");
 157                                 Assert.IsNotNull (ex.Message, "#4");
 158                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
 159                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
 160                                 Assert.AreEqual ("value", ex.ParamName, "#7");
 161                         }
 162                 }
 163
 164                 [Test] // Add (Object)
 165                 public void Add1_Value_Owned ()
 166                 {
 167                         OracleParameter param = new OracleParameter ("ParamI", 1);
 168
 169                         o.Add ((object) param);
 170
 171                         // attempt to add same OracleParameter to collection twice
 172                         try {
 173                                 o.Add ((object) param);
 174                                 Assert.Fail ("#A1");
 175                         } catch (ArgumentException ex) {
 176                                 // The OracleParameter is already contained by
 177                                 // another OracleParameterCollection
 178                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 179                                 Assert.IsNull (ex.InnerException, "#A3");
 180                                 Assert.IsNotNull (ex.Message, "#A4");
 181                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 182                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
 183                                 Assert.IsNull (ex.ParamName, "#A7");
 184                         }
 185
 186                         OracleParameterCollection o2 = new OracleParameterCollection ();
 187
 188                         // attempt to add OracleParameter to another collection
 189                         try {
 190                                 o2.Add ((object) param);
 191                                 Assert.Fail ("#B1");
 192                         } catch (ArgumentException ex) {
 193                                 // The OracleParameter is already contained by
 194                                 // another OracleParameterCollection
 195                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 196                                 Assert.IsNull (ex.InnerException, "#B3");
 197                                 Assert.IsNotNull (ex.Message, "#B4");
 198                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
 199                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B6");
 200                                 Assert.IsNull (ex.ParamName, "#B7");
 201                         }
 202
 203                         o.Remove ((object) param);
 204                         o.Add ((object) param);
 205                         o.Remove ((object) param);
 206                         o2.Add ((object) param);
 207                 }
 208
 209                 [Test] // Add (OracleParameter)
 210                 public void Add2_Value_Null ()
 211                 {
 212                         try {
 213                                 o.Add ((OracleParameter) null);
 214                                 Assert.Fail ("#1");
 215                         } catch (ArgumentNullException ex) {
 216                                 // The OracleParameterCollection only accepts
 217                                 // non-null OracleParameter type objects
 218                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 219                                 Assert.IsNull (ex.InnerException, "#3");
 220                                 Assert.IsNotNull (ex.Message, "#4");
 221                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
 222                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
 223                                 Assert.AreEqual ("value", ex.ParamName, "#7");
 224                         }
 225                 }
 226
 227                 [Test] // Add (OracleParameter)
 228                 public void Add2_Value_Owned ()
 229                 {
 230                         OracleParameter param = new OracleParameter ("ParamI", 1);
 231
 232                         o.Add (param);
 233
 234                         // attempt to add same OracleParameter to collection twice
 235                         try {
 236                                 o.Add (param);
 237                                 Assert.Fail ("#A1");
 238                         } catch (ArgumentException ex) {
 239                                 // The OracleParameter is already contained by
 240                                 // another OracleParameterCollection
 241                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 242                                 Assert.IsNull (ex.InnerException, "#A3");
 243                                 Assert.IsNotNull (ex.Message, "#A4");
 244                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 245                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
 246                                 Assert.IsNull (ex.ParamName, "#A7");
 247                         }
 248
 249                         OracleParameterCollection o2 = new OracleParameterCollection ();
 250
 251                         // attempt to add OracleParameter to another collection
 252                         try {
 253                                 o2.Add (param);
 254                                 Assert.Fail ("#B1");
 255                         } catch (ArgumentException ex) {
 256                                 // The OracleParameter is already contained by
 257                                 // another OracleParameterCollection
 258                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 259                                 Assert.IsNull (ex.InnerException, "#B3");
 260                                 Assert.IsNotNull (ex.Message, "#B4");
 261                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
 262                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B6");
 263                                 Assert.IsNull (ex.ParamName, "#B7");
 264                         }
 265
 266                         o.Remove (param);
 267                         o.Add (param);
 268                         o.Remove (param);
 269                         o2.Add (param);
 270                 }
 271
 272                 [Test] // AddRange (Array)
 273                 public void AddRange1 ()
 274                 {
 275                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 276                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 277                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 278                         OracleParameter paramD = new OracleParameter ("parami", 4);
 279
 280                         o.Add (paramA);
 281                         o.AddRange (new object [] { paramB, paramC, paramD });
 282
 283                         Assert.AreEqual (0, o.IndexOf (paramA), "#1");
 284                         Assert.AreEqual (1, o.IndexOf (paramB), "#2");
 285                         Assert.AreEqual (2, o.IndexOf (paramC), "#3");
 286                         Assert.AreEqual (3, o.IndexOf (paramD), "#4");
 287                 }
 288
 289                 [Test] // AddRange (Array)
 290                 public void AddRange1_Item_InvalidType ()
 291                 {
 292                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 293                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 294                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 295
 296                         o.Add (paramA);
 297
 298                         object [] values = new object [] { paramB, "ParamX", paramC };
 299                         try {
 300                                 o.AddRange (values);
 301                                 Assert.Fail ("#A1");
 302                         } catch (InvalidCastException ex) {
 303                                 // The OracleParameterCollection only accepts
 304                                 // non-null OracleParameter type objects, not
 305                                 // String objects
 306                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#A2");
 307                                 Assert.IsNull (ex.InnerException, "#A3");
 308                                 Assert.IsNotNull (ex.Message, "#A4");
 309                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 310                                 Assert.IsTrue (ex.Message.IndexOf (typeof (string).Name) != -1, "#A6");
 311                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#A7");
 312                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A8");
 313                         }
 314
 315                         Assert.AreEqual (0, o.IndexOf (paramA), "#B1");
 316                         Assert.AreEqual (-1, o.IndexOf (paramB), "#B2");
 317                         Assert.AreEqual (-1, o.IndexOf (paramC), "#B3");
 318                 }
 319
 320                 [Test] // AddRange (Array)
 321                 public void AddRange1_Item_Null ()
 322                 {
 323                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 324                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 325                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 326
 327                         o.Add (paramA);
 328
 329                         object [] values = new object [] { paramB, null, paramC };
 330                         try {
 331                                 o.AddRange (values);
 332                                 Assert.Fail ("#A1");
 333                         } catch (ArgumentNullException ex) {
 334                                 // The OracleParameterCollection only accepts
 335                                 // non-null OracleParameter type objects
 336                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 337                                 Assert.IsNull (ex.InnerException, "#A3");
 338                                 Assert.IsNotNull (ex.Message, "#A4");
 339                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 340                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
 341                                 Assert.AreEqual ("value", ex.ParamName, "#A7");
 342                         }
 343
 344                         Assert.AreEqual (0, o.IndexOf (paramA), "#B1");
 345                         Assert.AreEqual (-1, o.IndexOf (paramB), "#B2");
 346                         Assert.AreEqual (-1, o.IndexOf (paramC), "#B3");
 347                 }
 348
 349                 [Test] // AddRange (Array)
 350                 public void AddRange1_Item_Owned ()
 351                 {
 352                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 353                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 354                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 355
 356                         o.Add (paramA);
 357
 358                         object [] values = new object [] { paramB, paramA, paramC };
 359                         try {
 360                                 o.AddRange (values);
 361                                 Assert.Fail ("#A1");
 362                         } catch (ArgumentException ex) {
 363                                 // The OracleParameter is already contained by
 364                                 // another OracleParameterCollection
 365                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 366                                 Assert.IsNull (ex.InnerException, "#A3");
 367                                 Assert.IsNotNull (ex.Message, "#A4");
 368                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 369                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
 370                                 Assert.IsNull (ex.ParamName, "#A7");
 371                         }
 372
 373                         Assert.AreEqual (0, o.IndexOf (paramA), "#B1");
 374                         Assert.AreEqual (1, o.IndexOf (paramB), "#B2");
 375                         Assert.AreEqual (-1, o.IndexOf (paramC), "#B3");
 376                 }
 377
 378                 [Test] // AddRange (Array)
 379                 public void AddRange1_Values_Null ()
 380                 {
 381                         try {
 382                                 o.AddRange ((Array) null);
 383                                 Assert.Fail ("#1");
 384                         } catch (ArgumentNullException ex) {
 385                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 386                                 Assert.IsNull (ex.InnerException, "#3");
 387                                 Assert.IsNotNull (ex.Message, "#4");
 388                                 Assert.AreEqual ("values", ex.ParamName, "#5");
 389                         }
 390                 }
 391
 392                 [Test] // AddRange (OracleParameter [])
 393                 public void AddRange2 ()
 394                 {
 395                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 396                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 397                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 398                         OracleParameter paramD = new OracleParameter ("parami", 4);
 399
 400                         o.Add (paramA);
 401
 402                         OracleParameter [] values = new OracleParameter [] {
 403                                 paramB, paramC, paramD };
 404                         o.AddRange (values);
 405
 406                         Assert.AreEqual (0, o.IndexOf (paramA), "#1");
 407                         Assert.AreEqual (1, o.IndexOf (paramB), "#2");
 408                         Assert.AreEqual (2, o.IndexOf (paramC), "#3");
 409                         Assert.AreEqual (3, o.IndexOf (paramD), "#4");
 410                 }
 411
 412                 [Test] // AddRange (OracleParameter [])
 413                 public void AddRange2_Item_Null ()
 414                 {
 415                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 416                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 417                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 418
 419                         o.Add (paramA);
 420
 421                         OracleParameter [] values = new OracleParameter [] {
 422                                 paramB, null, paramC };
 423                         try {
 424                                 o.AddRange (values);
 425                                 Assert.Fail ("#A1");
 426                         } catch (ArgumentNullException ex) {
 427                                 // The OracleParameterCollection only accepts
 428                                 // non-null OracleParameter type objects
 429                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 430                                 Assert.IsNull (ex.InnerException, "#A3");
 431                                 Assert.IsNotNull (ex.Message, "#A4");
 432                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 433                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
 434                                 Assert.AreEqual ("value", ex.ParamName, "#A7");
 435                         }
 436
 437                         Assert.AreEqual (0, o.IndexOf (paramA), "#B1");
 438                         Assert.AreEqual (-1, o.IndexOf (paramB), "#B2");
 439                         Assert.AreEqual (-1, o.IndexOf (paramC), "#B3");
 440                 }
 441
 442                 [Test] // AddRange (OracleParameter [])
 443                 public void AddRange2_Item_Owned ()
 444                 {
 445                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 446                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 447                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 448
 449                         o.Add (paramA);
 450
 451                         OracleParameter [] values = new OracleParameter [] {
 452                                 paramB, paramA, paramC };
 453                         try {
 454                                 o.AddRange (values);
 455                                 Assert.Fail ("#A1");
 456                         } catch (ArgumentException ex) {
 457                                 // The OracleParameter is already contained by
 458                                 // another OracleParameterCollection
 459                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 460                                 Assert.IsNull (ex.InnerException, "#A3");
 461                                 Assert.IsNotNull (ex.Message, "#A4");
 462                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 463                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
 464                                 Assert.IsNull (ex.ParamName, "#A7");
 465                         }
 466
 467                         Assert.AreEqual (0, o.IndexOf (paramA), "#B1");
 468                         Assert.AreEqual (1, o.IndexOf (paramB), "#B2");
 469                         Assert.AreEqual (-1, o.IndexOf (paramC), "#B3");
 470                 }
 471
 472                 [Test] // AddRange (OracleParameter [])
 473                 public void AddRange2_Values_Null ()
 474                 {
 475                         try {
 476                                 o.AddRange ((OracleParameter []) null);
 477                                 Assert.Fail ("#1");
 478                         } catch (ArgumentNullException ex) {
 479                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 480                                 Assert.IsNull (ex.InnerException, "#3");
 481                                 Assert.IsNotNull (ex.Message, "#4");
 482                                 Assert.AreEqual ("values", ex.ParamName, "#5");
 483                         }
 484                 }
 485
 486                 [Test] // Contains (Object)
 487                 public void Contains1 ()
 488                 {
 489                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 490                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 491                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 492                         OracleParameter paramD = new OracleParameter ("parami", 4);
 493
 494                         o.Add (paramA);
 495                         o.Add (paramB);
 496
 497                         Assert.IsTrue (o.Contains ((object) paramA), "#A1");
 498                         Assert.IsTrue (o.Contains ((object) paramB), "#A2");
 499                         Assert.IsFalse (o.Contains ((object) paramC), "#A3");
 500                         Assert.IsFalse (o.Contains ((object) paramD), "#A4");
 501                         Assert.IsFalse (o.Contains ((object) null), "#A5");
 502
 503                         o.Add (paramC);
 504
 505                         Assert.IsTrue (o.Contains ((object) paramA), "#B1");
 506                         Assert.IsTrue (o.Contains ((object) paramB), "#B2");
 507                         Assert.IsTrue (o.Contains ((object) paramC), "#B3");
 508                         Assert.IsFalse (o.Contains ((object) paramD), "#B4");
 509                         Assert.IsFalse (o.Contains ((object) null), "#B5");
 510
 511                         o.Remove (paramA);
 512
 513                         Assert.IsFalse (o.Contains ((object) paramA), "#C1");
 514                         Assert.IsTrue (o.Contains ((object) paramB), "#C2");
 515                         Assert.IsTrue (o.Contains ((object) paramC), "#C3");
 516                         Assert.IsFalse (o.Contains ((object) paramD), "#C4");
 517                         Assert.IsFalse (o.Contains ((object) null), "#C5");
 518                 }
 519
 520                 [Test] // Contains (Object)
 521                 public void Contains1_Value_InvalidType ()
 522                 {
 523                         try {
 524                                 o.Contains ((object) "ParamI");
 525                                 Assert.Fail ("#A1");
 526                         } catch (InvalidCastException ex) {
 527                                 // The OracleParameterCollection only accepts
 528                                 // non-null OracleParameter type objects, not
 529                                 // String objects
 530                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#A2");
 531                                 Assert.IsNull (ex.InnerException, "#A3");
 532                                 Assert.IsNotNull (ex.Message, "#A4");
 533                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 534                                 Assert.IsTrue (ex.Message.IndexOf (typeof (string).Name) != -1, "#A6");
 535                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#A7");
 536                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A8");
 537                         }
 538
 539                         try {
 540                                 o.Contains ((object) 5);
 541                                 Assert.Fail ("#B1");
 542                         } catch (InvalidCastException ex) {
 543                                 // The OracleParameterCollection only accepts
 544                                 // non-null OracleParameter type objects, not
 545                                 // Int32 objects
 546                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#B2");
 547                                 Assert.IsNull (ex.InnerException, "#B3");
 548                                 Assert.IsNotNull (ex.Message, "#B4");
 549                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
 550                                 Assert.IsFalse (ex.Message.IndexOf (typeof (string).Name) != -1, "#B6");
 551                                 Assert.IsTrue (ex.Message.IndexOf (typeof (int).Name) != -1, "#B7");
 552                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B8");
 553                         }
 554                 }
 555
 556                 [Test] // Contains (OracleParameter)
 557                 public void Contains2 ()
 558                 {
 559                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 560                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 561                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 562                         OracleParameter paramD = new OracleParameter ("parami", 4);
 563
 564                         o.Add (paramA);
 565                         o.Add (paramB);
 566
 567                         Assert.IsTrue (o.Contains (paramA), "#A1");
 568                         Assert.IsTrue (o.Contains (paramB), "#A2");
 569                         Assert.IsFalse (o.Contains (paramC), "#A3");
 570                         Assert.IsFalse (o.Contains (paramD), "#A4");
 571                         Assert.IsFalse (o.Contains ((OracleParameter) null), "#A5");
 572
 573                         o.Add (paramC);
 574
 575                         Assert.IsTrue (o.Contains (paramA), "#B1");
 576                         Assert.IsTrue (o.Contains (paramB), "#B2");
 577                         Assert.IsTrue (o.Contains (paramC), "#B3");
 578                         Assert.IsFalse (o.Contains (paramD), "#B4");
 579                         Assert.IsFalse (o.Contains ((OracleParameter) null), "#B5");
 580
 581                         o.Remove (paramA);
 582
 583                         Assert.IsFalse (o.Contains (paramA), "#C1");
 584                         Assert.IsTrue (o.Contains (paramB), "#C2");
 585                         Assert.IsTrue (o.Contains (paramC), "#C3");
 586                         Assert.IsFalse (o.Contains (paramD), "#C4");
 587                         Assert.IsFalse (o.Contains ((OracleParameter) null), "#C5");
 588                 }
 589
 590                 [Test] // Contains (String)
 591                 public void Contains3 ()
 592                 {
 593                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 594                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 595                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 596                         OracleParameter paramD = new OracleParameter ("parami", 4);
 597
 598                         o.Add (paramA);
 599                         o.Add (paramB);
 600
 601                         Assert.IsTrue (o.Contains ("ParamI"), "#A1");
 602                         Assert.IsTrue (o.Contains ("Parami"), "#A2");
 603                         Assert.IsTrue (o.Contains ("paramI"), "#A3");
 604                         Assert.IsTrue (o.Contains ("parami"), "#A4");
 605                         Assert.IsFalse (o.Contains ("NotFound"), "#A5");
 606                         Assert.IsFalse (o.Contains ((OracleParameter) null), "#A6");
 607
 608                         o.Remove (paramA);
 609
 610                         Assert.IsFalse (o.Contains ("ParamI"), "#B1");
 611                         Assert.IsTrue (o.Contains ("Parami"), "#B2");
 612                         Assert.IsFalse (o.Contains ("paramI"), "#B3");
 613                         Assert.IsTrue (o.Contains ("parami"), "#B4");
 614                         Assert.IsFalse (o.Contains ("NotFound"), "#B5");
 615                         Assert.IsFalse (o.Contains ((OracleParameter) null), "#B6");
 616                 }
 617
 618                 [Test] // OracleParameter this [Int32]
 619                 public void Indexer1 ()
 620                 {
 621                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 622                         OracleParameter paramB = new OracleParameter ("paramI", 2);
 623                         OracleParameter paramC = new OracleParameter ("Parami", 3);
 624
 625                         o.Add (paramA);
 626                         o.Add (paramB);
 627
 628                         Assert.AreSame (paramA, o [0], "#A1");
 629                         Assert.AreSame (paramB, o [1], "#A2");
 630                         o [0] = paramA;
 631                         Assert.AreSame (paramA, o [0], "#B1");
 632                         Assert.AreSame (paramB, o [1], "#B2");
 633                         o [0] = paramC;
 634                         Assert.AreSame (paramC, o [0], "#C1");
 635                         Assert.AreSame (paramB, o [1], "#C2");
 636                         o [1] = paramA;
 637                         Assert.AreSame (paramC, o [0], "#D1");
 638                         Assert.AreSame (paramA, o [1], "#D2");
 639
 640                         OracleParameterCollection o2 = new OracleParameterCollection ();
 641                         o2.Add (paramB);
 642                 }
 643
 644                 [Test] // OracleParameter this [Int32]
 645                 public void Indexer1_Index_Invalid ()
 646                 {
 647                         o.Add (new OracleParameter ());
 648
 649                         try {
 650                                 o [1] = new OracleParameter ();
 651                                 Assert.Fail ("#A1");
 652                         } catch (IndexOutOfRangeException ex) {
 653                                 // Invalid index 1 for this OracleParameterCollection
 654                                 // with Count=1
 655                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
 656                                 Assert.IsNull (ex.InnerException, "#A3");
 657                                 Assert.IsNotNull (ex.Message, "#A4");
 658                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 659                         }
 660
 661                         try {
 662                                 o [-1] = new OracleParameter ();
 663                                 Assert.Fail ("#B1");
 664                         } catch (IndexOutOfRangeException ex) {
 665                                 // Invalid index -1 for this OracleParameterCollection
 666                                 // with Count=1
 667                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
 668                                 Assert.IsNull (ex.InnerException, "#B3");
 669                                 Assert.IsNotNull (ex.Message, "#B4");
 670                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
 671                         }
 672
 673                         try {
 674                                 object value = o [1];
 675                                 Assert.Fail ("#C1:" + value);
 676                         } catch (IndexOutOfRangeException ex) {
 677                                 // Invalid index 1 for this OracleParameterCollection
 678                                 // with Count=1
 679                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#C2");
 680                                 Assert.IsNull (ex.InnerException, "#C3");
 681                                 Assert.IsNotNull (ex.Message, "#C4");
 682                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#C5");
 683                         }
 684
 685                         try {
 686                                 object value = o [-1];
 687                                 Assert.Fail ("#D1");
 688                         } catch (IndexOutOfRangeException ex) {
 689                                 // Invalid index -1 for this OracleParameterCollection
 690                                 // with Count=1
 691                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#D2");
 692                                 Assert.IsNull (ex.InnerException, "#D3");
 693                                 Assert.IsNotNull (ex.Message, "#D4");
 694                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#D5");
 695                         }
 696                 }
 697
 698                 [Test] // OracleParameter this [Int32]
 699                 public void Indexer1_Value_Null ()
 700                 {
 701                         OracleParameter param = new OracleParameter ("ParamI", 1);
 702                         o.Add (param);
 703
 704                         try {
 705                                 o [0] = null;
 706                                 Assert.Fail ("#1");
 707                         } catch (ArgumentNullException ex) {
 708                                 // The OracleParameterCollection only accepts
 709                                 // non-null OracleParameter type objects
 710                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 711                                 Assert.IsNull (ex.InnerException, "#3");
 712                                 Assert.IsNotNull (ex.Message, "#4");
 713                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
 714                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
 715                                 Assert.AreEqual ("value", ex.ParamName, "#7");
 716                         }
 717                 }
 718
 719                 [Test] // OracleParameter this [Int32]
 720                 public void Indexer1_Value_Owned ()
 721                 {
 722                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 723                         OracleParameter paramB = new OracleParameter ("paramI", 2);
 724                         OracleParameter paramC = new OracleParameter ("Parami", 3);
 725
 726                         o.Add (paramA);
 727                         o.Add (paramB);
 728
 729                         // attempt to add same OracleParameter to collection twice
 730                         try {
 731                                 o [1] = paramA;
 732                                 Assert.Fail ("#A1");
 733                         } catch (ArgumentException ex) {
 734                                 // The OracleParameter is already contained by
 735                                 // another OracleParameterCollection
 736                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 737                                 Assert.IsNull (ex.InnerException, "#A3");
 738                                 Assert.IsNotNull (ex.Message, "#A4");
 739                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 740                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
 741                                 Assert.IsNull (ex.ParamName, "#A7");
 742                         }
 743
 744                         OracleParameterCollection o2 = new OracleParameterCollection ();
 745                         o2.Add (paramC);
 746
 747                         // attempt to add OracleParameter to another collection
 748                         try {
 749                                 o2 [0] = paramA;
 750                                 Assert.Fail ("#B1");
 751                         } catch (ArgumentException ex) {
 752                                 // The OracleParameter is already contained by
 753                                 // another OracleParameterCollection
 754                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 755                                 Assert.IsNull (ex.InnerException, "#B3");
 756                                 Assert.IsNotNull (ex.Message, "#B4");
 757                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
 758                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B6");
 759                                 Assert.IsNull (ex.ParamName, "#B7");
 760                         }
 761
 762                         o.Remove (paramA);
 763                         o [0] = paramA;
 764                         o.Remove (paramA);
 765                         o2 [0] = paramA;
 766                 }
 767
 768                 [Test] // OracleParameter this [String]
 769                 public void Indexer2 ()
 770                 {
 771                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 772                         OracleParameter paramB = new OracleParameter ("Parami", 2);
 773                         OracleParameter paramC = new OracleParameter ("paramI", 3);
 774                         OracleParameter paramD = new OracleParameter ("parami", 4);
 775                         OracleParameter paramE = new OracleParameter ("ParamI", 5);
 776                         OracleParameter paramF = new OracleParameter ("Parami", 6);
 777                         OracleParameter paramG = new OracleParameter ("ParamG", 7);
 778                         OracleParameter paramH = new OracleParameter ("ParamH", 8);
 779
 780                         o.Add (paramA);
 781                         o.Add (paramB);
 782                         o.Add (paramC);
 783                         o.Add (paramD);
 784                         o.Add (paramE);
 785                         o.Add (paramF);
 786
 787                         Assert.AreSame (paramA, o ["ParamI"], "#A1");
 788                         Assert.AreSame (paramB, o ["Parami"], "#A2");
 789                         Assert.AreSame (paramC, o ["paramI"], "#A3");
 790                         Assert.AreSame (paramD, o ["parami"], "#A4");
 791                         Assert.AreEqual (0, o.IndexOf (paramA), "#A5");
 792                         Assert.AreEqual (1, o.IndexOf (paramB), "#A6");
 793                         Assert.AreEqual (2, o.IndexOf (paramC), "#A7");
 794                         Assert.AreEqual (3, o.IndexOf (paramD), "#A8");
 795                         Assert.AreEqual (4, o.IndexOf (paramE), "#A9");
 796                         Assert.AreEqual (5, o.IndexOf (paramF), "#A10");
 797                         Assert.AreEqual (-1, o.IndexOf (paramG), "#A11");
 798                         Assert.AreEqual (-1, o.IndexOf (paramH), "#A12");
 799
 800                         o ["ParamI"] = paramG;
 801                         Assert.AreSame (paramE, o ["ParamI"], "#B1");
 802                         Assert.AreSame (paramB, o ["Parami"], "#B2");
 803                         Assert.AreSame (paramC, o ["paramI"], "#B3");
 804                         Assert.AreSame (paramD, o ["parami"], "#B4");
 805                         Assert.AreSame (paramG, o ["paramG"], "#B5");
 806                         Assert.AreEqual (-1, o.IndexOf (paramA), "#B6");
 807                         Assert.AreEqual (1, o.IndexOf (paramB), "#B7");
 808                         Assert.AreEqual (2, o.IndexOf (paramC), "#B8");
 809                         Assert.AreEqual (3, o.IndexOf (paramD), "#B9");
 810                         Assert.AreEqual (4, o.IndexOf (paramE), "#B10");
 811                         Assert.AreEqual (5, o.IndexOf (paramF), "#B11");
 812                         Assert.AreEqual (0, o.IndexOf (paramG), "#B12");
 813                         Assert.AreEqual (-1, o.IndexOf (paramH), "#B13");
 814
 815                         o ["ParamI"] = paramH;
 816                         Assert.AreSame (paramC, o ["ParamI"], "#C1");
 817                         Assert.AreSame (paramB, o ["Parami"], "#C2");
 818                         Assert.AreSame (paramC, o ["paramI"], "#C3");
 819                         Assert.AreSame (paramD, o ["parami"], "#C4");
 820                         Assert.AreSame (paramG, o ["paramG"], "#C5");
 821                         Assert.AreSame (paramH, o ["paramH"], "#C6");
 822                         Assert.AreEqual (-1, o.IndexOf (paramA), "#C6");
 823                         Assert.AreEqual (1, o.IndexOf (paramB), "#C7");
 824                         Assert.AreEqual (2, o.IndexOf (paramC), "#C8");
 825                         Assert.AreEqual (3, o.IndexOf (paramD), "#C9");
 826                         Assert.AreEqual (-1, o.IndexOf (paramE), "#C10");
 827                         Assert.AreEqual (5, o.IndexOf (paramF), "#C11");
 828                         Assert.AreEqual (0, o.IndexOf (paramG), "#C12");
 829                         Assert.AreEqual (4, o.IndexOf (paramH), "#C13");
 830
 831                         o ["paramG"] = paramA;
 832                         Assert.AreSame (paramA, o ["ParamI"], "#D1");
 833                         Assert.AreSame (paramB, o ["Parami"], "#D2");
 834                         Assert.AreSame (paramC, o ["paramI"], "#D3");
 835                         Assert.AreSame (paramD, o ["parami"], "#D4");
 836                         Assert.AreSame (paramH, o ["paramH"], "#D5");
 837                         Assert.AreEqual (0, o.IndexOf (paramA), "#D6");
 838                         Assert.AreEqual (1, o.IndexOf (paramB), "#D7");
 839                         Assert.AreEqual (2, o.IndexOf (paramC), "#D8");
 840                         Assert.AreEqual (3, o.IndexOf (paramD), "#D9");
 841                         Assert.AreEqual (-1, o.IndexOf (paramE), "#D10");
 842                         Assert.AreEqual (5, o.IndexOf (paramF), "#D11");
 843                         Assert.AreEqual (-1, o.IndexOf (paramG), "#D12");
 844                         Assert.AreEqual (4, o.IndexOf (paramH), "#D13");
 845
 846                         o ["ParamI"] = paramA;
 847                         Assert.AreSame (paramA, o ["ParamI"], "#E1");
 848                         Assert.AreSame (paramB, o ["Parami"], "#E2");
 849                         Assert.AreSame (paramC, o ["paramI"], "#E3");
 850                         Assert.AreSame (paramD, o ["parami"], "#E4");
 851                         Assert.AreSame (paramH, o ["paramH"], "#E5");
 852                         Assert.AreEqual (0, o.IndexOf (paramA), "#E6");
 853                         Assert.AreEqual (1, o.IndexOf (paramB), "#E7");
 854                         Assert.AreEqual (2, o.IndexOf (paramC), "#E8");
 855                         Assert.AreEqual (3, o.IndexOf (paramD), "#E9");
 856                         Assert.AreEqual (-1, o.IndexOf (paramE), "#E10");
 857                         Assert.AreEqual (5, o.IndexOf (paramF), "#E11");
 858                         Assert.AreEqual (-1, o.IndexOf (paramG), "#E12");
 859                         Assert.AreEqual (4, o.IndexOf (paramH), "#E13");
 860
 861                         o ["paramI"] = paramC;
 862                         Assert.AreSame (paramA, o ["ParamI"], "#F1");
 863                         Assert.AreSame (paramB, o ["Parami"], "#F2");
 864                         Assert.AreSame (paramC, o ["paramI"], "#F3");
 865                         Assert.AreSame (paramD, o ["parami"], "#F4");
 866                         Assert.AreSame (paramH, o ["paramH"], "#F5");
 867                         Assert.AreEqual (0, o.IndexOf (paramA), "#F6");
 868                         Assert.AreEqual (1, o.IndexOf (paramB), "#F7");
 869                         Assert.AreEqual (2, o.IndexOf (paramC), "#F8");
 870                         Assert.AreEqual (3, o.IndexOf (paramD), "#F9");
 871                         Assert.AreEqual (-1, o.IndexOf (paramE), "#F10");
 872                         Assert.AreEqual (5, o.IndexOf (paramF), "#F11");
 873                         Assert.AreEqual (-1, o.IndexOf (paramG), "#F12");
 874                         Assert.AreEqual (4, o.IndexOf (paramH), "#F13");
 875
 876                         OracleParameterCollection o2 = new OracleParameterCollection ();
 877                         o2.Add (paramE);
 878                 }
 879
 880                 [Test] // OracleParameter this [String]
 881                 public void Indexer2_ParameterName_NotFound ()
 882                 {
 883                         OracleParameter param = new OracleParameter ("ParamI", 1);
 884                         o.Add (param);
 885
 886                         try {
 887                                 o ["NotFound"] = new OracleParameter ();
 888                                 Assert.Fail ("#A1");
 889                         } catch (IndexOutOfRangeException ex) {
 890                                 // Invalid index -1 for this OracleParameterCollection
 891                                 // with Count=1
 892                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
 893                                 Assert.IsNull (ex.InnerException, "#A3");
 894                                 Assert.IsNotNull (ex.Message, "#A4");
 895                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 896                                 Assert.IsFalse (ex.Message.IndexOf ("'NotFound'") != -1, "#A6");
 897                         }
 898
 899                         try {
 900                                 o [(string) null] = new OracleParameter ();
 901                                 Assert.Fail ("#B1");
 902                         } catch (IndexOutOfRangeException ex) {
 903                                 // Invalid index -1 for this OracleParameterCollection
 904                                 // with Count=1
 905                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
 906                                 Assert.IsNull (ex.InnerException, "#B3");
 907                                 Assert.IsNotNull (ex.Message, "#B4");
 908                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
 909                                 Assert.IsFalse (ex.Message.IndexOf ("''") != -1, "#B6");
 910                         }
 911
 912                         try {
 913                                 object value = o ["NotFound"];
 914                                 Assert.Fail ("#C1:" + value);
 915                         } catch (IndexOutOfRangeException ex) {
 916                                 // Invalid index -1 for this OracleParameterCollection
 917                                 // with Count=1
 918                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#C2");
 919                                 Assert.IsNull (ex.InnerException, "#C3");
 920                                 Assert.IsNotNull (ex.Message, "#C4");
 921                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#C5");
 922                                 Assert.IsFalse (ex.Message.IndexOf ("'NotFound'") != -1, "#C6");
 923                         }
 924
 925                         try {
 926                                 object value = o [(string) null];
 927                                 Assert.Fail ("#D1:" + value);
 928                         } catch (IndexOutOfRangeException ex) {
 929                                 // Invalid index -1 for this OracleParameterCollection
 930                                 // with Count=1
 931                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#D2");
 932                                 Assert.IsNull (ex.InnerException, "#D3");
 933                                 Assert.IsNotNull (ex.Message, "#D4");
 934                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#D5");
 935                                 Assert.IsFalse (ex.Message.IndexOf ("''") != -1, "#D6");
 936                         }
 937                 }
 938
 939                 [Test] // OracleParameter this [String]
 940                 public void Indexer2_Value_Null ()
 941                 {
 942                         OracleParameter param = new OracleParameter ("ParamI", 1);
 943                         o.Add (param);
 944
 945                         try {
 946                                 o ["ParamI"] = null;
 947                                 Assert.Fail ("#1");
 948                         } catch (ArgumentNullException ex) {
 949                                 // The OracleParameterCollection only accepts
 950                                 // non-null OracleParameter type objects
 951                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 952                                 Assert.IsNull (ex.InnerException, "#3");
 953                                 Assert.IsNotNull (ex.Message, "#4");
 954                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
 955                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
 956                                 Assert.AreEqual ("value", ex.ParamName, "#7");
 957                         }
 958                 }
 959
 960                 [Test] // OracleParameter this [String]
 961                 public void Indexer2_Value_Owned ()
 962                 {
 963                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
 964                         OracleParameter paramB = new OracleParameter ("paramI", 2);
 965                         OracleParameter paramC = new OracleParameter ("Parami", 3);
 966
 967                         o.Add (paramA);
 968                         o.Add (paramB);
 969
 970                         // attempt to add same OracleParameter to collection twice
 971                         try {
 972                                 o ["paramI"] = paramA;
 973                                 Assert.Fail ("#A1");
 974                         } catch (ArgumentException ex) {
 975                                 // The OracleParameter is already contained by
 976                                 // another OracleParameterCollection
 977                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 978                                 Assert.IsNull (ex.InnerException, "#A3");
 979                                 Assert.IsNotNull (ex.Message, "#A4");
 980                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
 981                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
 982                                 Assert.IsNull (ex.ParamName, "#A7");
 983                         }
 984
 985                         OracleParameterCollection o2 = new OracleParameterCollection ();
 986                         o2.Add (paramC);
 987
 988                         // attempt to add OracleParameter to another collection
 989                         try {
 990                                 o2 ["Parami"] = paramA;
 991                                 Assert.Fail ("#B1");
 992                         } catch (ArgumentException ex) {
 993                                 // The OracleParameter is already contained by
 994                                 // another OracleParameterCollection
 995                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 996                                 Assert.IsNull (ex.InnerException, "#B3");
 997                                 Assert.IsNotNull (ex.Message, "#B4");
 998                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
 999                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B6");
1000                                 Assert.IsNull (ex.ParamName, "#B7");
1001                         }
1002
1003                         o.Remove (paramA);
1004                         o ["paramI"] = paramA;
1005                         o.Remove (paramA);
1006                         o2 ["Parami"] = paramA;
1007                 }
1008
1009                 [Test] // IndexOf (Object)
1010                 public void IndexOf1 ()
1011                 {
1012                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1013                         OracleParameter paramB = new OracleParameter ("Parami", 2);
1014                         OracleParameter paramC = new OracleParameter ("paramI", 3);
1015                         OracleParameter paramD = new OracleParameter ("parami", 4);
1016                         OracleParameter paramE = new OracleParameter ("ParamI", 1);
1017                         OracleParameter paramF = new OracleParameter ("Parami", 2);
1018
1019                         o.Add (paramA);
1020                         o.Add (paramB);
1021
1022                         Assert.AreEqual (1, o.IndexOf ((object) paramB), "#A1");
1023                         Assert.AreEqual (0, o.IndexOf ((object) paramA), "#A2");
1024                         Assert.AreEqual (-1, o.IndexOf ((object) paramD), "#A3");
1025                         Assert.AreEqual (-1, o.IndexOf ((object) paramC), "#A4");
1026                         Assert.AreEqual (-1, o.IndexOf ((object) paramF), "#A5");
1027                         Assert.AreEqual (-1, o.IndexOf ((object) paramE), "#A6");
1028                         Assert.AreEqual (-1, o.IndexOf ((object) null), "#A7");
1029
1030                         o.Add (paramC);
1031                         o.Add (paramD);
1032
1033                         Assert.AreEqual (1, o.IndexOf ((object) paramB), "#B1");
1034                         Assert.AreEqual (0, o.IndexOf ((object) paramA), "#B2");
1035                         Assert.AreEqual (3, o.IndexOf ((object) paramD), "#B3");
1036                         Assert.AreEqual (2, o.IndexOf ((object) paramC), "#B4");
1037                         Assert.AreEqual (-1, o.IndexOf ((object) paramF), "#B5");
1038                         Assert.AreEqual (-1, o.IndexOf ((object) paramE), "#B6");
1039                         Assert.AreEqual (-1, o.IndexOf ((object) null), "#B7");
1040                 }
1041
1042                 [Test] // IndexOf (Object)
1043                 public void IndexOf1_Value_InvalidType ()
1044                 {
1045                         try {
1046                                 o.IndexOf ((object) "ParamI");
1047                                 Assert.Fail ("#A1");
1048                         } catch (InvalidCastException ex) {
1049                                 // The OracleParameterCollection only accepts
1050                                 // non-null OracleParameter type objects, not
1051                                 // String objects
1052                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#A2");
1053                                 Assert.IsNull (ex.InnerException, "#A3");
1054                                 Assert.IsNotNull (ex.Message, "#A4");
1055                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1056                                 Assert.IsTrue (ex.Message.IndexOf (typeof (string).Name) != -1, "#A6");
1057                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#A7");
1058                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A8");
1059                         }
1060
1061                         try {
1062                                 o.IndexOf ((object) 5);
1063                                 Assert.Fail ("#B1");
1064                         } catch (InvalidCastException ex) {
1065                                 // The OracleParameterCollection only accepts
1066                                 // non-null OracleParameter type objects, not
1067                                 // Int32 objects
1068                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#B2");
1069                                 Assert.IsNull (ex.InnerException, "#B3");
1070                                 Assert.IsNotNull (ex.Message, "#B4");
1071                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1072                                 Assert.IsFalse (ex.Message.IndexOf (typeof (string).Name) != -1, "#B6");
1073                                 Assert.IsTrue (ex.Message.IndexOf (typeof (int).Name) != -1, "#B7");
1074                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B8");
1075                         }
1076                 }
1077
1078                 [Test] // IndexOf (OracleParameter)
1079                 public void IndexOf2 ()
1080                 {
1081                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1082                         OracleParameter paramB = new OracleParameter ("Parami", 2);
1083                         OracleParameter paramC = new OracleParameter ("paramI", 3);
1084                         OracleParameter paramD = new OracleParameter ("parami", 4);
1085                         OracleParameter paramE = new OracleParameter ("ParamI", 1);
1086                         OracleParameter paramF = new OracleParameter ("Parami", 2);
1087
1088                         o.Add (paramA);
1089                         o.Add (paramB);
1090
1091                         Assert.AreEqual (1, o.IndexOf (paramB), "#A1");
1092                         Assert.AreEqual (0, o.IndexOf (paramA), "#A2");
1093                         Assert.AreEqual (-1, o.IndexOf (paramD), "#A3");
1094                         Assert.AreEqual (-1, o.IndexOf (paramC), "#A4");
1095                         Assert.AreEqual (-1, o.IndexOf (paramF), "#A5");
1096                         Assert.AreEqual (-1, o.IndexOf (paramE), "#A6");
1097                         Assert.AreEqual (-1, o.IndexOf (null), "#A7");
1098
1099                         o.Add (paramC);
1100                         o.Add (paramD);
1101
1102                         Assert.AreEqual (1, o.IndexOf (paramB), "#B1");
1103                         Assert.AreEqual (0, o.IndexOf (paramA), "#B2");
1104                         Assert.AreEqual (3, o.IndexOf (paramD), "#B3");
1105                         Assert.AreEqual (2, o.IndexOf (paramC), "#B4");
1106                         Assert.AreEqual (-1, o.IndexOf (paramF), "#B5");
1107                         Assert.AreEqual (-1, o.IndexOf (paramE), "#B6");
1108                         Assert.AreEqual (-1, o.IndexOf (null), "#B7");
1109                 }
1110
1111                 [Test] // IndexOf (String)
1112                 public void IndexOf3 ()
1113                 {
1114                         OracleParameter paramA = new OracleParameter ("ParamI", 5);
1115                         OracleParameter paramB = new OracleParameter ("Parami", 4);
1116
1117                         o.Add (paramA);
1118                         o.Add (paramB);
1119
1120                         Assert.AreEqual (1, o.IndexOf ("Parami"), "#1");
1121                         Assert.AreEqual (0, o.IndexOf ("ParamI"), "#2");
1122                         Assert.AreEqual (0, o.IndexOf ("paramI"), "#3");
1123                         Assert.AreEqual (1, o.IndexOf ("parami"), "#4");
1124                         Assert.AreEqual (-1, o.IndexOf ("NotFound"), "#5");
1125                         Assert.AreEqual (-1, o.IndexOf (string.Empty), "#6");
1126                         Assert.AreEqual (-1, o.IndexOf ((string) null), "#7");
1127                 }
1128
1129                 [Test] // Insert (Int32, Object)
1130                 public void Insert1_Value_InvalidType ()
1131                 {
1132                         OracleParameter param = new OracleParameter ("ParamI", 1);
1133
1134                         o.Insert (0, (object) param);
1135
1136                         try {
1137                                 o.Insert (0, (object) "ParamI");
1138                                 Assert.Fail ("#A1");
1139                         } catch (InvalidCastException ex) {
1140                                 // The OracleParameterCollection only accepts
1141                                 // non-null OracleParameter type objects, not
1142                                 // String objects
1143                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#A2");
1144                                 Assert.IsNull (ex.InnerException, "#A3");
1145                                 Assert.IsNotNull (ex.Message, "#A4");
1146                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1147                                 Assert.IsTrue (ex.Message.IndexOf (typeof (string).Name) != -1, "#A6");
1148                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#A7");
1149                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A8");
1150                         }
1151
1152                         try {
1153                                 o.Insert (0, (object) 5);
1154                                 Assert.Fail ("#B1");
1155                         } catch (InvalidCastException ex) {
1156                                 // The OracleParameterCollection only accepts
1157                                 // non-null OracleParameter type objects, not
1158                                 // Int32 objects
1159                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#B2");
1160                                 Assert.IsNull (ex.InnerException, "#B3");
1161                                 Assert.IsNotNull (ex.Message, "#B4");
1162                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1163                                 Assert.IsFalse (ex.Message.IndexOf (typeof (string).Name) != -1, "#B6");
1164                                 Assert.IsTrue (ex.Message.IndexOf (typeof (int).Name) != -1, "#B7");
1165                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B8");
1166                         }
1167                 }
1168
1169                 [Test] // Insert (Int32, Object)
1170                 public void Insert1_Value_Null ()
1171                 {
1172                         try {
1173                                 o.Insert (0, (object) null);
1174                                 Assert.Fail ("#1");
1175                         } catch (ArgumentNullException ex) {
1176                                 // The OracleParameterCollection only accepts
1177                                 // non-null OracleParameter type objects
1178                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1179                                 Assert.IsNull (ex.InnerException, "#3");
1180                                 Assert.IsNotNull (ex.Message, "#4");
1181                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
1182                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
1183                                 Assert.AreEqual ("value", ex.ParamName, "#7");
1184                         }
1185                 }
1186
1187                 [Test] // Insert (Int32, Object)
1188                 public void Insert1_Value_Owned ()
1189                 {
1190                         OracleParameter param = new OracleParameter ("ParamI", 1);
1191
1192                         o.Insert (0, (object) param);
1193
1194                         // attempt to add same OracleParameter to collection twice
1195                         try {
1196                                 o.Insert (1, (object) param);
1197                                 Assert.Fail ("#A1");
1198                         } catch (ArgumentException ex) {
1199                                 // The OracleParameter is already contained by
1200                                 // another OracleParameterCollection
1201                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1202                                 Assert.IsNull (ex.InnerException, "#A3");
1203                                 Assert.IsNotNull (ex.Message, "#A4");
1204                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1205                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
1206                                 Assert.IsNull (ex.ParamName, "#A7");
1207                         }
1208
1209                         OracleParameterCollection o2 = new OracleParameterCollection ();
1210
1211                         // attempt to add OracleParameter to another collection
1212                         try {
1213                                 o2.Insert (0, (object) param);
1214                                 Assert.Fail ("#B1");
1215                         } catch (ArgumentException ex) {
1216                                 // The OracleParameter is already contained by
1217                                 // another OracleParameterCollection
1218                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1219                                 Assert.IsNull (ex.InnerException, "#B3");
1220                                 Assert.IsNotNull (ex.Message, "#B4");
1221                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1222                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B6");
1223                                 Assert.IsNull (ex.ParamName, "#B7");
1224                         }
1225
1226                         o.Remove (param);
1227                         o.Insert (0, (object) param);
1228                         o.Remove (param);
1229                         o2.Insert (0, (object) param);
1230                 }
1231
1232                 [Test] // Insert (Int32, OracleParameter)
1233                 public void Insert2_Value_Null ()
1234                 {
1235                         try {
1236                                 o.Insert (0, (OracleParameter) null);
1237                                 Assert.Fail ("#1");
1238                         } catch (ArgumentNullException ex) {
1239                                 // The OracleParameterCollection only accepts
1240                                 // non-null OracleParameter type objects
1241                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1242                                 Assert.IsNull (ex.InnerException, "#3");
1243                                 Assert.IsNotNull (ex.Message, "#4");
1244                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
1245                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
1246                                 Assert.AreEqual ("value", ex.ParamName, "#7");
1247                         }
1248                 }
1249
1250                 [Test] // Insert (Int32, OracleParameter)
1251                 public void Insert2_Value_Owned ()
1252                 {
1253                         OracleParameter param = new OracleParameter ("ParamI", 1);
1254
1255                         o.Insert (0, param);
1256
1257                         // attempt to add same OracleParameter to collection twice
1258                         try {
1259                                 o.Insert (1, param);
1260                                 Assert.Fail ("#A1");
1261                         } catch (ArgumentException ex) {
1262                                 // The OracleParameter is already contained by
1263                                 // another OracleParameterCollection
1264                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1265                                 Assert.IsNull (ex.InnerException, "#A3");
1266                                 Assert.IsNotNull (ex.Message, "#A4");
1267                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1268                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A6");
1269                                 Assert.IsNull (ex.ParamName, "#A7");
1270                         }
1271
1272                         OracleParameterCollection o2 = new OracleParameterCollection ();
1273
1274                         // attempt to add OracleParameter to another collection
1275                         try {
1276                                 o2.Insert (0, param);
1277                                 Assert.Fail ("#B1");
1278                         } catch (ArgumentException ex) {
1279                                 // The OracleParameter is already contained by
1280                                 // another OracleParameterCollection
1281                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1282                                 Assert.IsNull (ex.InnerException, "#B3");
1283                                 Assert.IsNotNull (ex.Message, "#B4");
1284                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1285                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B6");
1286                                 Assert.IsNull (ex.ParamName, "#B7");
1287                         }
1288
1289                         o.Remove (param);
1290                         o.Insert (0, param);
1291                         o.Remove (param);
1292                         o2.Insert (0, param);
1293                 }
1294
1295                 [Test] // Remove (Object)
1296                 public void Remove1 ()
1297                 {
1298                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1299                         OracleParameter paramB = new OracleParameter ("Parami", 2);
1300                         OracleParameter paramC = new OracleParameter ("paramI", 3);
1301
1302                         o.Add (paramA);
1303                         o.Add (paramB);
1304                         o.Remove ((object) paramA);
1305
1306                         Assert.AreEqual (-1, o.IndexOf (paramA), "#A1");
1307                         Assert.AreEqual (0, o.IndexOf (paramB), "#A2");
1308
1309                         o.Add (paramA);
1310
1311                         Assert.AreEqual (1, o.IndexOf (paramA), "#B1");
1312                         Assert.AreEqual (0, o.IndexOf (paramB), "#B2");
1313
1314                         o.Remove ((object) paramB);
1315
1316                         Assert.AreEqual (0, o.IndexOf (paramA), "#C1");
1317                         Assert.AreEqual (-1, o.IndexOf (paramB), "#C2");
1318
1319                         OracleParameterCollection o2 = new OracleParameterCollection ();
1320                         o2.Add (paramB);
1321                 }
1322
1323                 [Test] // Remove (Object)
1324                 public void Remove1_Value_InvalidType ()
1325                 {
1326                         try {
1327                                 o.Remove ((object) "ParamI");
1328                                 Assert.Fail ("#A1");
1329                         } catch (InvalidCastException ex) {
1330                                 // The OracleParameterCollection only accepts
1331                                 // non-null OracleParameter type objects, not
1332                                 // String objects
1333                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#A2");
1334                                 Assert.IsNull (ex.InnerException, "#A3");
1335                                 Assert.IsNotNull (ex.Message, "#A4");
1336                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1337                                 Assert.IsTrue (ex.Message.IndexOf (typeof (string).Name) != -1, "#A6");
1338                                 Assert.IsFalse (ex.Message.IndexOf (typeof (int).Name) != -1, "#A7");
1339                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A8");
1340                         }
1341
1342                         try {
1343                                 o.Remove ((object) 5);
1344                                 Assert.Fail ("#B1");
1345                         } catch (InvalidCastException ex) {
1346                                 // The OracleParameterCollection only accepts
1347                                 // non-null OracleParameter type objects, not
1348                                 // Int32 objects
1349                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#B2");
1350                                 Assert.IsNull (ex.InnerException, "#B3");
1351                                 Assert.IsNotNull (ex.Message, "#B4");
1352                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1353                                 Assert.IsFalse (ex.Message.IndexOf (typeof (string).Name) != -1, "#B6");
1354                                 Assert.IsTrue (ex.Message.IndexOf (typeof (int).Name) != -1, "#B7");
1355                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B8");
1356                         }
1357                 }
1358
1359                 [Test] // Remove (Object)
1360                 public void Remove1_Value_NotOwned ()
1361                 {
1362                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1363
1364                         try {
1365                                 o.Remove ((object) paramA);
1366                                 Assert.Fail ("#1");
1367                         } catch (ArgumentException ex) {
1368                                 // Attempted to remove an OracleParameter that
1369                                 // is not contained by this OracleParameterCollection
1370                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1371                                 Assert.IsNull (ex.InnerException, "#B3");
1372                                 Assert.IsNotNull (ex.Message, "#B4");
1373                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1374                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B6");
1375                                 Assert.IsNull (ex.ParamName, "#B7");
1376                         }
1377                 }
1378
1379                 [Test] // Remove (Object)
1380                 public void Remove1_Value_Null ()
1381                 {
1382                         try {
1383                                 o.Remove ((object) null);
1384                                 Assert.Fail ("#1");
1385                         } catch (ArgumentNullException ex) {
1386                                 // The OracleParameterCollection only accepts
1387                                 // non-null OracleParameter type objects
1388                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1389                                 Assert.IsNull (ex.InnerException, "#3");
1390                                 Assert.IsNotNull (ex.Message, "#4");
1391                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
1392                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
1393                                 Assert.AreEqual ("value", ex.ParamName, "#7");
1394                         }
1395                 }
1396
1397                 [Test] // Remove (OracleParameter)
1398                 public void Remove2 ()
1399                 {
1400                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1401                         OracleParameter paramB = new OracleParameter ("Parami", 2);
1402                         OracleParameter paramC = new OracleParameter ("paramI", 3);
1403
1404                         o.Add (paramA);
1405                         o.Add (paramB);
1406                         o.Remove (paramA);
1407
1408                         Assert.AreEqual (-1, o.IndexOf (paramA), "#A1");
1409                         Assert.AreEqual (0, o.IndexOf (paramB), "#A2");
1410
1411                         o.Add (paramA);
1412
1413                         Assert.AreEqual (1, o.IndexOf (paramA), "#B1");
1414                         Assert.AreEqual (0, o.IndexOf (paramB), "#B2");
1415
1416                         o.Remove (paramB);
1417
1418                         Assert.AreEqual (0, o.IndexOf (paramA), "#C1");
1419                         Assert.AreEqual (-1, o.IndexOf (paramB), "#C2");
1420
1421                         OracleParameterCollection o2 = new OracleParameterCollection ();
1422                         o2.Add (paramB);
1423                 }
1424
1425                 [Test] // Remove (OracleParameter)
1426                 public void Remove2_Value_NotOwned ()
1427                 {
1428                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1429
1430                         try {
1431                                 o.Remove (paramA);
1432                                 Assert.Fail ("#1");
1433                         } catch (ArgumentException ex) {
1434                                 // Attempted to remove an OracleParameter that
1435                                 // is not contained by this OracleParameterCollection
1436                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1437                                 Assert.IsNull (ex.InnerException, "#3");
1438                                 Assert.IsNotNull (ex.Message, "#4");
1439                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
1440                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
1441                                 Assert.IsNull (ex.ParamName, "#7");
1442                         }
1443                 }
1444
1445                 [Test] // Remove (OracleParameter)
1446                 public void Remove2_Value_Null ()
1447                 {
1448                         try {
1449                                 o.Remove ((OracleParameter) null);
1450                                 Assert.Fail ("#1");
1451                         } catch (ArgumentNullException ex) {
1452                                 // The OracleParameterCollection only accepts
1453                                 // non-null OracleParameter type objects
1454                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1455                                 Assert.IsNull (ex.InnerException, "#3");
1456                                 Assert.IsNotNull (ex.Message, "#4");
1457                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#5");
1458                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#6");
1459                                 Assert.AreEqual ("value", ex.ParamName, "#7");
1460                         }
1461                 }
1462
1463                 [Test] // RemoveAt (Int32)
1464                 public void RemoveAt1 ()
1465                 {
1466                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1467                         OracleParameter paramB = new OracleParameter ("Parami", 2);
1468                         OracleParameter paramC = new OracleParameter ("paramI", 3);
1469
1470                         o.Add (paramA);
1471                         o.Add (paramB);
1472                         o.Add (paramC);
1473
1474                         o.RemoveAt (2);
1475
1476                         Assert.AreEqual (0, o.IndexOf (paramA), "#A1");
1477                         Assert.AreEqual (1, o.IndexOf (paramB), "#A2");
1478                         Assert.AreEqual (-1, o.IndexOf (paramC), "#A3");
1479
1480                         o.RemoveAt (0);
1481
1482                         Assert.AreEqual (-1, o.IndexOf (paramA), "#B1");
1483                         Assert.AreEqual (0, o.IndexOf (paramB), "#B2");
1484                         Assert.AreEqual (-1, o.IndexOf (paramC), "#B3");
1485
1486                         o.RemoveAt (0);
1487
1488                         Assert.AreEqual (-1, o.IndexOf (paramA), "#C1");
1489                         Assert.AreEqual (-1, o.IndexOf (paramB), "#C2");
1490                         Assert.AreEqual (-1, o.IndexOf (paramC), "#C3");
1491
1492                         o.Add (paramA);
1493                         o.Add (paramC);
1494
1495                         OracleParameterCollection o2 = new OracleParameterCollection ();
1496                         o2.Add (paramB);
1497                 }
1498
1499                 [Test] // RemoveAt (Int32)
1500                 public void RemoveAt1_Index_Invalid ()
1501                 {
1502                         try {
1503                                 o.RemoveAt (0);
1504                                 Assert.Fail ("#A1");
1505                         } catch (IndexOutOfRangeException ex) {
1506                                 // Invalid index 0 for this OracleParameterCollection
1507                                 // with Count=0
1508                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
1509                                 Assert.IsNull (ex.InnerException, "#A3");
1510                                 Assert.IsNotNull (ex.Message, "#A4");
1511                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A5");
1512                         }
1513
1514                         try {
1515                                 o.RemoveAt (-1);
1516                                 Assert.Fail ("#B1");
1517                         } catch (IndexOutOfRangeException ex) {
1518                                 // Invalid index -1 for this OracleParameterCollection
1519                                 // with Count=0
1520                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
1521                                 Assert.IsNull (ex.InnerException, "#B3");
1522                                 Assert.IsNotNull (ex.Message, "#B4");
1523                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B5");
1524                         }
1525                 }
1526
1527                 [Test] // RemoveAt (String)
1528                 public void RemoveAt2 ()
1529                 {
1530                         OracleParameter paramA = new OracleParameter ("ParamI", 1);
1531                         OracleParameter paramB = new OracleParameter ("Parami", 2);
1532                         OracleParameter paramC = new OracleParameter ("paramI", 3);
1533                         OracleParameter paramD = new OracleParameter ("parami", 4);
1534                         OracleParameter paramE = new OracleParameter ("parami", 5);
1535
1536                         o.Add (paramA);
1537                         o.Add (paramB);
1538                         o.Add (paramC);
1539                         o.Add (paramD);
1540                         o.Add (paramE);
1541
1542                         o.RemoveAt ("paramI");
1543
1544                         Assert.AreEqual (0, o.IndexOf (paramA), "#A1");
1545                         Assert.AreEqual (1, o.IndexOf (paramB), "#A2");
1546                         Assert.AreEqual (-1, o.IndexOf (paramC), "#A3");
1547                         Assert.AreEqual (2, o.IndexOf (paramD), "#A4");
1548                         Assert.AreEqual (3, o.IndexOf (paramE), "#A5");
1549
1550                         o.RemoveAt ("parami");
1551
1552                         Assert.AreEqual (0, o.IndexOf (paramA), "#B1");
1553                         Assert.AreEqual (1, o.IndexOf (paramB), "#B2");
1554                         Assert.AreEqual (-1, o.IndexOf (paramC), "#B3");
1555                         Assert.AreEqual (-1, o.IndexOf (paramD), "#B4");
1556                         Assert.AreEqual (2, o.IndexOf (paramE), "#B5");
1557
1558                         o.RemoveAt ("Parami");
1559
1560                         Assert.AreEqual (0, o.IndexOf (paramA), "#C1");
1561                         Assert.AreEqual (-1, o.IndexOf (paramB), "#C2");
1562                         Assert.AreEqual (-1, o.IndexOf (paramC), "#C3");
1563                         Assert.AreEqual (-1, o.IndexOf (paramD), "#C4");
1564                         Assert.AreEqual (1, o.IndexOf (paramE), "#C5");
1565
1566                         o.RemoveAt ("Parami");
1567
1568                         Assert.AreEqual (0, o.IndexOf (paramA), "#D1");
1569                         Assert.AreEqual (-1, o.IndexOf (paramB), "#D2");
1570                         Assert.AreEqual (-1, o.IndexOf (paramC), "#D3");
1571                         Assert.AreEqual (-1, o.IndexOf (paramD), "#D4");
1572                         Assert.AreEqual (-1, o.IndexOf (paramE), "#D5");
1573
1574                         o.RemoveAt ("ParamI");
1575
1576                         Assert.AreEqual (-1, o.IndexOf (paramA), "#E1");
1577                         Assert.AreEqual (-1, o.IndexOf (paramB), "#E2");
1578                         Assert.AreEqual (-1, o.IndexOf (paramC), "#E3");
1579                         Assert.AreEqual (-1, o.IndexOf (paramD), "#E4");
1580                         Assert.AreEqual (-1, o.IndexOf (paramE), "#E5");
1581
1582                         o.Add (paramA);
1583                         o.Add (paramB);
1584                         o.Add (paramE);
1585
1586                         OracleParameterCollection o2 = new OracleParameterCollection ();
1587                         o2.Add (paramC);
1588                         o2.Add (paramD);
1589                 }
1590
1591                 [Test] // RemoveAt (String)
1592                 public void RemoveAt2_ParameterName_NotFound ()
1593                 {
1594                         o.Add (new OracleParameter ((string) null, 1));
1595                         o.Add (new OracleParameter (string.Empty, 1));
1596
1597                         try {
1598                                 o.RemoveAt ("NotFound");
1599                                 Assert.Fail ("#A1");
1600                         } catch (IndexOutOfRangeException ex) {
1601                                 // An OracleParameter with ParameterName 'NotFound'
1602                                 // is not contained by this OracleParameterCollection
1603                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
1604                                 Assert.IsNull (ex.InnerException, "#A3");
1605                                 Assert.IsNotNull (ex.Message, "#A4");
1606                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#A5");
1607                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#A6");
1608                                 Assert.IsTrue (ex.Message.IndexOf ("'NotFound'") != -1, "#A7");
1609                         }
1610
1611                         try {
1612                                 o.RemoveAt ((string) null);
1613                                 Assert.Fail ("#B1");
1614                         } catch (IndexOutOfRangeException ex) {
1615                                 // An OracleParameter with ParameterName '' is
1616                                 // not contained by this OracleParameterCollection
1617                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
1618                                 Assert.IsNull (ex.InnerException, "#B3");
1619                                 Assert.IsNotNull (ex.Message, "#B4");
1620                                 Assert.IsTrue (ex.Message.IndexOf (typeof (OracleParameter).Name) != -1, "#B5");
1621                                 Assert.IsTrue (ex.Message.IndexOf (o.GetType ().Name) != -1, "#B6");
1622                                 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#B7");
1623                         }
1624                 }
1625         }
1626 }