mcs/class/corlib/Test/System.Collections/ArrayListTest.cs

   1 // ArrayListTest.cs - NUnit Test Cases for the System.Collections.ArrayList class
   2 //
   3 // David Brandt (bucky@keystreams.com)
   4 //
   5 // (C) Ximian, Inc.  http://www.ximian.com
   6 //
   7
   8 using System;
   9 using System.Collections;
  10
  11 using NUnit.Framework;
  12
  13 namespace MonoTests.System.Collections {
  14
  15 [TestFixture]
  16 public class ArrayListTest : Assertion {
  17
  18         public void TestCtor() {
  19                 {
  20                         ArrayList al1 = new ArrayList();
  21                         AssertNotNull("no basic ArrayList", al1);
  22                 }
  23                 {
  24                         bool errorThrown = false;
  25                         try {
  26                                 ArrayList a = new ArrayList(null);
  27                         } catch (ArgumentNullException) {
  28                                 errorThrown = true;
  29                         }
  30                         Assert("null icollection error not thrown",
  31                                errorThrown);
  32                 }
  33                 {
  34                         // what can I say?  I like chars.  [--DB]
  35                         char[] coll = {'a', 'b', 'c', 'd'};
  36                         ArrayList al1 = new ArrayList(coll);
  37                         AssertNotNull("no icollection ArrayList", al1);
  38                         for (int i = 0; i < coll.Length; i++) {
  39                                 AssertEquals(i + " not ctor'ed properly.",
  40                                              coll[i], al1[i]);
  41                         }
  42                 }
  43                 {
  44                         try {
  45                                 Char[,] c1 = new Char[2,2];
  46                                 ArrayList al1 = new ArrayList(c1);
  47                                 Fail ("Should fail with multi-dimensional array in constructor.");
  48                         } catch (RankException) {
  49                         }
  50                 }
  51
  52                 {
  53                         bool errorThrown = false;
  54                         try {
  55                                 ArrayList a = new ArrayList(-1);
  56                         } catch (ArgumentOutOfRangeException) {
  57                                 errorThrown = true;
  58                         }
  59                         Assert("negative capacity error not thrown",
  60                                errorThrown);
  61                 }
  62         }
  63
  64         public void TestCapacity() {
  65                 for (int i = 1; i < 100; i++) {
  66                         ArrayList al1 = new ArrayList(i);
  67                         AssertEquals("Bad capacity of " + i,
  68                                      i, al1.Capacity);
  69                 }
  70                 {
  71                         ArrayList al1 = new ArrayList(0);
  72                         // LAMESPEC:
  73                         // AssertEquals("Bad capacity when set to 0",
  74                         //           16, al1.Capacity);
  75                         al1.Add ("?");
  76                         AssertEquals("Bad capacity when set to 0",
  77                                      16, al1.Capacity);
  78                 }
  79                 {
  80                         ArrayList al1 = new ArrayList();
  81                         AssertEquals("Bad default capacity",
  82                                      16, al1.Capacity);
  83                 }
  84         }
  85
  86         public void TestCount() {
  87                 {
  88                         ArrayList al1 = new ArrayList();
  89                         AssertEquals("Bad initial count",
  90                                      0, al1.Count);
  91                         for (int i = 1; i <= 100; i++) {
  92                                 al1.Add(i);
  93                                 AssertEquals("Bad count " + i,
  94                                              i, al1.Count);
  95                         }
  96                 }
  97                 for (int i = 0; i < 100; i++) {
  98                         char[] coll = new Char[i];
  99                         ArrayList al1 = new ArrayList(coll);
 100                         AssertEquals("Bad count for " + i,
 101                                      i, al1.Count);
 102                 }
 103         }
 104
 105         public void TestIsFixed() {
 106                 ArrayList al1 = new ArrayList();
 107                 Assert("should not be fixed by default", !al1.IsFixedSize);
 108                 ArrayList al2 = ArrayList.FixedSize(al1);
 109                 Assert("fixed-size wrapper not working", al2.IsFixedSize);
 110         }
 111
 112         public void TestIsReadOnly() {
 113                 ArrayList al1 = new ArrayList();
 114                 Assert("should not be ReadOnly by default", !al1.IsReadOnly);
 115                 ArrayList al2 = ArrayList.ReadOnly(al1);
 116                 Assert("read-only wrapper not working", al2.IsReadOnly);
 117         }
 118
 119         public void TestIsSynchronized() {
 120                 ArrayList al1 = new ArrayList();
 121                 Assert("should not be synchronized by default",
 122                        !al1.IsSynchronized);
 123                 ArrayList al2 = ArrayList.Synchronized(al1);
 124                 Assert("synchronized wrapper not working", al2.IsSynchronized);
 125         }
 126
 127         public void TestItem() {
 128                 ArrayList al1 = new ArrayList();
 129                 {
 130                         bool errorThrown = false;
 131                         try {
 132                                 object o = al1[-1];
 133                         } catch (ArgumentOutOfRangeException) {
 134                                 errorThrown = true;
 135                         }
 136                         Assert("negative item error not thrown",
 137                                errorThrown);
 138                 }
 139                 {
 140                         bool errorThrown = false;
 141                         try {
 142                                 object o = al1[1];
 143                         } catch (ArgumentOutOfRangeException) {
 144                                 errorThrown = true;
 145                         }
 146                         Assert("past-end item error not thrown",
 147                                errorThrown);
 148                 }
 149                 for (int i = 0; i <= 100; i++) {
 150                         al1.Add(i);
 151                 }
 152                 for (int i = 0; i <= 100; i++) {
 153                         AssertEquals("item not fetched for " + i,
 154                                      i, al1[i]);
 155                 }
 156         }
 157
 158         public void TestAdapter() {
 159                 {
 160                         bool errorThrown = false;
 161                         try {
 162                                 ArrayList al1 = ArrayList.Adapter(null);
 163                         } catch (ArgumentNullException) {
 164                                 errorThrown = true;
 165                         } catch (Exception e) {
 166                                 Fail ("Incorrect exception thrown at 1: " + e.ToString());
 167                         }
 168                         Assert("null adapter error not thrown",
 169                                errorThrown);
 170                 }
 171                 {
 172                         char[] list = {'a', 'b', 'c', 'd'};
 173                         ArrayList al1 = ArrayList.Adapter(list);
 174                         AssertNotNull("Couldn't get an adapter", al1);
 175                         for (int i = 0; i < list.Length; i++) {
 176                                 AssertEquals("adapter not adapting", list[i], al1[i]);
 177                         }
 178                         list[0] = 'z';
 179                         for (int i = 0; i < list.Length; i++) {
 180                                 AssertEquals("adapter not adapting", list[i], al1[i]);
 181                         }
 182                 }
 183                 // Test Binary Search
 184                 {
 185                 bool errorThrown = false;
 186                 try {
 187
 188                         String[] s1 = {"This", "is", "a", "test"};
 189                         ArrayList al1 = ArrayList.Adapter (s1);
 190                         al1.BinarySearch(42);
 191                 } catch (InvalidOperationException) {
 192                         // this is what .NET throws
 193                         errorThrown = true;
 194                 } catch (ArgumentException) {
 195                         // this is what the docs say it should throw
 196                         errorThrown = true;
 197                 } catch (Exception e) {
 198                         Fail ("Incorrect exception thrown at 1: " + e.ToString());
 199                 }
 200                 Assert("search-for-wrong-type error not thrown",
 201                        errorThrown);
 202                 }
 203
 204                 {
 205                         char[] arr = {'a', 'b', 'b', 'c', 'c', 'c', 'd', 'd'};
 206                         ArrayList al1 = ArrayList.Adapter (arr);
 207                         Assert("couldn't find elem #1",
 208                                al1.BinarySearch('c') >= 3);
 209                         Assert("couldn't find elem #2",
 210                                al1.BinarySearch('c') < 6);
 211                 }
 212                 {
 213                         char[] arr = {'a', 'b', 'b', 'd', 'd', 'd', 'e', 'e'};
 214                         ArrayList al1 = ArrayList.Adapter (arr);
 215                         AssertEquals("couldn't find next-higher elem",
 216                                      -4, al1.BinarySearch('c'));
 217                 }
 218                 {
 219                         char[] arr = {'a', 'b', 'b', 'c', 'c', 'c', 'd', 'd'};
 220                         ArrayList al1 = ArrayList.Adapter (arr);
 221                         AssertEquals("couldn't find end",
 222                                      -9, al1.BinarySearch('e'));
 223                 }
 224                 // Sort
 225                 {
 226                         char[] starter = {'d', 'b', 'f', 'e', 'a', 'c'};
 227                         ArrayList al1 = ArrayList.Adapter (starter);
 228                         al1.Sort();
 229                         AssertEquals("Should be sorted", 'a', al1[0]);
 230                         AssertEquals("Should be sorted", 'b', al1[1]);
 231                         AssertEquals("Should be sorted", 'c', al1[2]);
 232                         AssertEquals("Should be sorted", 'd', al1[3]);
 233                         AssertEquals("Should be sorted", 'e', al1[4]);
 234                         AssertEquals("Should be sorted", 'f', al1[5]);
 235                 }
 236
 237                 // TODO - test other adapter types?
 238         }
 239
 240         public void TestAdd() {
 241                 {
 242                         bool errorThrown = false;
 243                         try {
 244                                 ArrayList al1 =
 245                                         ArrayList.FixedSize(new ArrayList());
 246                                 al1.Add("Hi!");
 247                         } catch (NotSupportedException) {
 248                                 errorThrown = true;
 249                         } catch (Exception e) {
 250                                 Fail ("Incorrect exception thrown at 1: " + e.ToString());
 251                         }
 252                         Assert("add to fixed size error not thrown",
 253                                errorThrown);
 254                 }
 255                 {
 256                         bool errorThrown = false;
 257                         try {
 258                                 ArrayList al1 =
 259                                         ArrayList.ReadOnly(new ArrayList());
 260                                 al1.Add("Hi!");
 261                         } catch (NotSupportedException) {
 262                                 errorThrown = true;
 263                         } catch (Exception e) {
 264                                 Fail ("Incorrect exception thrown at 2: " + e.ToString());
 265                         }
 266                         Assert("add to read only error not thrown",
 267                                errorThrown);
 268                 }
 269                 {
 270                         ArrayList al1 = new ArrayList();
 271                         for (int i = 1; i <= 100; i++) {
 272                                 al1.Add(i);
 273                                 AssertEquals("add failed " + i,
 274                                              i, al1.Count);
 275                                 AssertEquals("add failed " + i,
 276                                              i, al1[i-1]);
 277
 278                         }
 279                 }
 280                 {
 281                         string [] strArray = new string [] {};
 282                         ArrayList al1 = new ArrayList (strArray);
 283                         al1.Add ("Hi!");
 284                         al1.Add ("Hi!");
 285                         AssertEquals ("add failed", 2, al1.Count);
 286                 }
 287         }
 288
 289         public void TestAddRange() {
 290                 {
 291                         bool errorThrown = false;
 292                         try {
 293                                 ArrayList al1 =
 294                                         ArrayList.FixedSize(new ArrayList());
 295                                 String[] s1 = {"Hi!"};
 296                                 al1.AddRange(s1);
 297                         } catch (NotSupportedException) {
 298                                 errorThrown = true;
 299                         } catch (Exception e) {
 300                                 Fail ("Incorrect exception thrown at 1: " + e.ToString());
 301                         }
 302                         Assert("add to fixed size error not thrown",
 303                                errorThrown);
 304                 }
 305                 {
 306                         bool errorThrown = false;
 307                         try {
 308                                 ArrayList al1 =
 309                                         ArrayList.ReadOnly(new ArrayList());
 310                                 String[] s1 = {"Hi!"};
 311                                 al1.AddRange(s1);
 312                         } catch (NotSupportedException) {
 313                                 errorThrown = true;
 314                         } catch (Exception e) {
 315                                 Fail ("Incorrect exception thrown at 2: " + e.ToString());
 316                         }
 317                         Assert("add to read only error not thrown",
 318                                errorThrown);
 319                 }
 320                 {
 321                         bool errorThrown = false;
 322                         try {
 323                                 ArrayList al1 = new ArrayList();
 324                                 al1.AddRange(null);
 325                         } catch (ArgumentNullException) {
 326                                 errorThrown = true;
 327                         } catch (Exception e) {
 328                                 Fail ("Incorrect exception thrown at 3: " + e.ToString());
 329                         }
 330                         Assert("add to read only error not thrown",
 331                                errorThrown);
 332                 }
 333
 334                 {
 335                         ArrayList a1 = new ArrayList();
 336                         AssertEquals("ArrayList should start empty",
 337                                      0, a1.Count);
 338                         char[] coll = {'a', 'b', 'c'};
 339                         a1.AddRange(coll);
 340                         AssertEquals("ArrayList has wrong elements",
 341                                      3, a1.Count);
 342                         a1.AddRange(coll);
 343                         AssertEquals("ArrayList has wrong elements",
 344                                      6, a1.Count);
 345                 }
 346
 347                 {
 348                         ArrayList list = new ArrayList ();
 349
 350                         for (int i = 0; i < 100; i ++) {
 351                                 list.Add (1);
 352                         }
 353
 354                         AssertEquals ("BinarySearch off-by-one bug",
 355                                         49, list.BinarySearch (1));
 356                 }
 357         }
 358
 359         public void TestBinarySearch() {
 360                 {
 361                 bool errorThrown = false;
 362                 try {
 363                         ArrayList al1 = new ArrayList();
 364                         String[] s1 = {"This", "is", "a", "test"};
 365                         al1.AddRange(s1);
 366                         al1.BinarySearch(42);
 367                 } catch (InvalidOperationException) {
 368                         // this is what .NET throws
 369                         errorThrown = true;
 370                 } catch (ArgumentException) {
 371                         // this is what the docs say it should throw
 372                         errorThrown = true;
 373                 } catch (Exception e) {
 374                         Fail ("Incorrect exception thrown at 1: " + e.ToString());
 375                 }
 376                 Assert("search-for-wrong-type error not thrown",
 377                        errorThrown);
 378                 }
 379
 380                 {
 381                         char[] arr = {'a', 'b', 'b', 'c', 'c', 'c', 'd', 'd'};
 382                         ArrayList al1 = new ArrayList(arr);
 383                         Assert("couldn't find elem #1",
 384                                al1.BinarySearch('c') >= 3);
 385                         Assert("couldn't find elem #2",
 386                                al1.BinarySearch('c') < 6);
 387                 }
 388                 {
 389                         char[] arr = {'a', 'b', 'b', 'd', 'd', 'd', 'e', 'e'};
 390                         ArrayList al1 = new ArrayList(arr);
 391                         AssertEquals("couldn't find next-higher elem",
 392                                      -4, al1.BinarySearch('c'));
 393                 }
 394                 {
 395                         char[] arr = {'a', 'b', 'b', 'c', 'c', 'c', 'd', 'd'};
 396                         ArrayList al1 = new ArrayList(arr);
 397                         AssertEquals("couldn't find end",
 398                                      -9, al1.BinarySearch('e'));
 399                 }
 400
 401         }
 402
 403         [Test]
 404         [ExpectedException (typeof (ArgumentException))]
 405         public void BinarySearch_IndexOverflow ()
 406         {
 407                 ArrayList al = new ArrayList ();
 408                 al.Add (this);
 409                 al.BinarySearch (Int32.MaxValue, 1, this, null);
 410         }
 411
 412         [Test]
 413         [ExpectedException (typeof (ArgumentException))]
 414         public void BinarySearch_CountOverflow ()
 415         {
 416                 ArrayList al = new ArrayList ();
 417                 al.Add (this);
 418                 al.BinarySearch (1, Int32.MaxValue, this, null);
 419         }
 420
 421         [Test]
 422         public void BinarySearch_Null ()
 423         {
 424                 ArrayList al = new ArrayList ();
 425                 al.Add (this);
 426                 AssertEquals ("null", -1, al.BinarySearch (null));
 427         }
 428
 429         // TODO - BinarySearch with IComparer
 430
 431         public void TestClear() {
 432                 {
 433                         bool errorThrown = false;
 434                         try {
 435                                 ArrayList al1 =
 436                                         ArrayList.FixedSize(new ArrayList());
 437                                 al1.Clear();
 438                         } catch (NotSupportedException) {
 439                                 errorThrown = true;
 440                         }
 441                         Assert("add to fixed size error not thrown",
 442                                errorThrown);
 443                 }
 444                 {
 445                         bool errorThrown = false;
 446                         try {
 447                                 ArrayList al1 =
 448                                         ArrayList.ReadOnly(new ArrayList());
 449                                 al1.Clear();
 450                         } catch (NotSupportedException) {
 451                                 errorThrown = true;
 452                         }
 453                         Assert("add to read only error not thrown",
 454                                errorThrown);
 455                 }
 456                 {
 457                         ArrayList al1 = new ArrayList();
 458                         al1.Add('c');
 459                         AssertEquals("should have one element",
 460                                      1, al1.Count);
 461                         al1.Clear();
 462                         AssertEquals("should be empty",
 463                                      0, al1.Count);
 464                 }
 465                 {
 466                         int[] i1 = {1,2,3,4};
 467                         ArrayList al1 = new ArrayList(i1);
 468                         AssertEquals("should have elements",
 469                                      i1.Length, al1.Count);
 470                         int capacity = al1.Capacity;
 471                         al1.Clear();
 472                         AssertEquals("should be empty again",
 473                                      0, al1.Count);
 474                         AssertEquals("capacity shouldn't have changed",
 475                                      capacity, al1.Capacity);
 476                 }
 477         }
 478
 479         public void TestClone() {
 480                 {
 481                         char[] c1 = {'a', 'b', 'c'};
 482                         ArrayList al1 = new ArrayList(c1);
 483                         ArrayList al2 = (ArrayList)al1.Clone();
 484                         AssertEquals("ArrayList match", al1[0], al2[0]);
 485                         AssertEquals("ArrayList match", al1[1], al2[1]);
 486                         AssertEquals("ArrayList match", al1[2], al2[2]);
 487                 }
 488                 {
 489                         char[] d10 = {'a', 'b'};
 490                         char[] d11 = {'a', 'c'};
 491                         char[] d12 = {'b', 'c'};
 492                         char[][] d1 = {d10, d11, d12};
 493                         ArrayList al1 = new ArrayList(d1);
 494                         ArrayList al2 = (ArrayList)al1.Clone();
 495                         AssertEquals("Array match", al1[0], al2[0]);
 496                         AssertEquals("Array match", al1[1], al2[1]);
 497                         AssertEquals("Array match", al1[2], al2[2]);
 498
 499                         ((char[])al1[0])[0] = 'z';
 500                         AssertEquals("shallow copy", al1[0], al2[0]);
 501                 }
 502         }
 503
 504         public void TestContains() {
 505                 char[] c1 = {'a', 'b', 'c'};
 506                 ArrayList al1 = new ArrayList(c1);
 507                 Assert("never find a null", !al1.Contains(null));
 508                 Assert("can't find value", al1.Contains('b'));
 509                 Assert("shouldn't find value", !al1.Contains('?'));
 510         }
 511
 512         public void TestCopyTo() {
 513                 {
 514                         bool errorThrown = false;
 515                         try {
 516                                 Char[] c1 = new Char[2];
 517                                 ArrayList al1 = new ArrayList(c1);
 518                                 al1.CopyTo(null, 2);
 519                         } catch (ArgumentNullException) {
 520                                 errorThrown = true;
 521                         } catch (Exception e) {
 522                                 Fail ("Incorrect exception thrown at 1: " + e.ToString());
 523                         }
 524                         Assert("error not thrown 1", errorThrown);
 525                 }
 526                 {
 527                         bool errorThrown = false;
 528                         try {
 529                                 Char[] c1 = new Char[2];
 530                                 ArrayList al1 = new ArrayList(c1);
 531                                 Char[,] c2 = new Char[2,2];
 532                                 al1.CopyTo(c2, 2);
 533                         } catch (ArgumentException) {
 534                                 errorThrown = true;
 535                         } catch (Exception e) {
 536                                 Fail ("Incorrect exception thrown at 2: " + e.ToString());
 537                         }
 538                         Assert("error not thrown 2", errorThrown);
 539                 }
 540                 {
 541                         bool errorThrown = false;
 542                         try {
 543                                 // This appears to be a bug in the ArrayList Constructor.
 544                                 // It throws a RankException if a multidimensional Array
 545                                 // is passed. The docs imply that an IEnumerator is used
 546                                 // to retrieve the items from the collection, so this should
 547                                 // work.  In anycase this test is for CopyTo, so use what
 548                                 // works on both platforms.
 549                                 //Char[,] c1 = new Char[2,2];
 550                                 Char[] c1 = new Char[2];
 551                                 ArrayList al1 = new ArrayList(c1);
 552                                 Char[] c2 = new Char[2];
 553                                 al1.CopyTo(c2, 2);
 554                         } catch (ArgumentException) {
 555                                 errorThrown = true;
 556                         } catch (Exception e) {
 557                                 Fail ("Incorrect exception thrown at 3: " + e.ToString());
 558                         }
 559                         Assert("error not thrown 3", errorThrown);
 560                 }
 561                 {
 562                         bool errorThrown = false;
 563                         try {
 564                                 Char[] c1 = new Char[2];
 565                                 ArrayList al1 = new ArrayList(c1);
 566                                 Char[] c2 = new Char[2];
 567                                 al1.CopyTo(c2, -1);
 568                         } catch (ArgumentOutOfRangeException) {
 569                                 errorThrown = true;
 570                         } catch (Exception e) {
 571                                 Fail ("Incorrect exception thrown at 4: " + e.ToString());
 572                         }
 573                         Assert("error not thrown 4", errorThrown);
 574                 }
 575                 {
 576                         bool errorThrown = false;
 577                         try {
 578                                 Char[] c1 = new Char[2];
 579                                 ArrayList al1 = new ArrayList(c1);
 580                                 Char[] c2 = new Char[2];
 581                                 al1.CopyTo(c2, 3);
 582                         } catch (ArgumentException) {
 583                                 errorThrown = true;
 584                         } catch (Exception e) {
 585                                 Fail ("Incorrect exception thrown at 5: " + e.ToString());
 586                         }
 587                         Assert("error not thrown 5", errorThrown);
 588                 }
 589                 {
 590                         bool errorThrown = false;
 591                         try {
 592                                 Char[] c1 = new Char[2];
 593                                 ArrayList al1 = new ArrayList(c1);
 594                                 Char[] c2 = new Char[2];
 595                                 al1.CopyTo(c2, 1);
 596                         } catch (ArgumentException) {
 597                                 errorThrown = true;
 598                         } catch (Exception e) {
 599                                 Fail ("Incorrect exception thrown at 6: " + e.ToString());
 600                         }
 601                         Assert("error not thrown 6", errorThrown);
 602                 }
 603                 {
 604                         bool errorThrown = false;
 605                         try {
 606                                 String[] c1 = {"String", "array"};
 607                                 ArrayList al1 = new ArrayList(c1);
 608                                 Char[] c2 = new Char[2];
 609                                 al1.CopyTo(c2, 0);
 610                         } catch (InvalidCastException) {
 611                                 errorThrown = true;
 612                         } catch (Exception e) {
 613                                 Fail ("Incorrect exception thrown at 7: " + e.ToString());
 614                         }
 615                         Assert("error not thrown 7", errorThrown);
 616                 }
 617
 618                 Char[] orig = {'a', 'b', 'c', 'd'};
 619                 ArrayList al = new ArrayList(orig);
 620                 Char[] copy = new Char[10];
 621                 Array.Clear(copy, 0, copy.Length);
 622                 al.CopyTo(copy, 3);
 623                 AssertEquals("Wrong CopyTo 0", (char)0, copy[0]);
 624                 AssertEquals("Wrong CopyTo 1", (char)0, copy[1]);
 625                 AssertEquals("Wrong CopyTo 2", (char)0, copy[2]);
 626                 AssertEquals("Wrong CopyTo 3", orig[0], copy[3]);
 627                 AssertEquals("Wrong CopyTo 4", orig[1], copy[4]);
 628                 AssertEquals("Wrong CopyTo 5", orig[2], copy[5]);
 629                 AssertEquals("Wrong CopyTo 6", orig[3], copy[6]);
 630                 AssertEquals("Wrong CopyTo 7", (char)0, copy[7]);
 631                 AssertEquals("Wrong CopyTo 8", (char)0, copy[8]);
 632                 AssertEquals("Wrong CopyTo 9", (char)0, copy[9]);
 633         }
 634
 635         [Test]
 636         [ExpectedException (typeof (ArgumentException))]
 637         public void CopyTo_IndexOverflow ()
 638         {
 639                 ArrayList al = new ArrayList ();
 640                 al.Add (this);
 641                 al.CopyTo (Int32.MaxValue, new byte [2], 0, 0);
 642         }
 643
 644         [Test]
 645         [ExpectedException (typeof (ArgumentException))]
 646         public void CopyTo_ArrayIndexOverflow ()
 647         {
 648                 ArrayList al = new ArrayList ();
 649                 al.Add (this);
 650                 al.CopyTo (0, new byte [2], Int32.MaxValue, 0);
 651         }
 652
 653         [Test]
 654         [ExpectedException (typeof (ArgumentException))]
 655         public void CopyTo_CountOverflow ()
 656         {
 657                 ArrayList al = new ArrayList ();
 658                 al.Add (this);
 659                 al.CopyTo (0, new byte [2], 0, Int32.MaxValue);
 660         }
 661
 662         public void TestFixedSize() {
 663                 {
 664                         bool errorThrown = false;
 665                         try {
 666                                 ArrayList al1 = ArrayList.FixedSize(null);
 667                         } catch (ArgumentNullException) {
 668                                 errorThrown = true;
 669                         }
 670                         Assert("null arg error not thrown", errorThrown);
 671                 }
 672                 {
 673                         ArrayList al1 = new ArrayList();
 674                         AssertEquals("arrays start un-fixed.",
 675                                      false, al1.IsFixedSize);
 676                         ArrayList al2 = ArrayList.FixedSize(al1);
 677                         AssertEquals("should be fixed.",
 678                                      true, al2.IsFixedSize);
 679                 }
 680         }
 681
 682         public void TestEnumerator() {
 683                 String[] s1 = {"this", "is", "a", "test"};
 684                 ArrayList al1 = new ArrayList(s1);
 685                 IEnumerator en = al1.GetEnumerator();
 686                 en.MoveNext();
 687                 al1.Add("something");
 688                 try {
 689                         en.MoveNext();
 690                         Fail("Add() didn't invalidate the enumerator");
 691                 } catch (InvalidOperationException) {
 692                         // do nothing...this is what we expect
 693                 }
 694
 695                 en = al1.GetEnumerator();
 696                 en.MoveNext();
 697                 al1.AddRange(al1);
 698                 try {
 699                         en.MoveNext();
 700                         Fail("AddRange() didn't invalidate the enumerator");
 701                 } catch (InvalidOperationException) {
 702                         // do nothing...this is what we expect
 703                 }
 704
 705                 en = al1.GetEnumerator();
 706                 en.MoveNext();
 707                 al1.Clear();
 708                 try {
 709                         en.MoveNext();
 710                         Fail("Clear() didn't invalidate the enumerator");
 711                 } catch (InvalidOperationException) {
 712                         // do nothing...this is what we expect
 713                 }
 714
 715                 al1 = new ArrayList(s1);
 716                 en = al1.GetEnumerator();
 717                 en.MoveNext();
 718                 al1.Insert(0, "new first");
 719                 try {
 720                         en.MoveNext();
 721                         Fail("Insert() didn't invalidate the enumerator");
 722                 } catch (InvalidOperationException) {
 723                         // do nothing...this is what we expect
 724                 }
 725
 726                 en = al1.GetEnumerator();
 727                 en.MoveNext();
 728                 al1.InsertRange(0, al1);
 729                 try {
 730                         en.MoveNext();
 731                         Fail("InsertRange() didn't invalidate the enumerator");
 732                 } catch (InvalidOperationException) {
 733                         // do nothing...this is what we expect
 734                 }
 735
 736                 en = al1.GetEnumerator();
 737                 en.MoveNext();
 738                 al1.Remove("this");
 739                 try {
 740                         en.MoveNext();
 741                         Fail("Remove() didn't invalidate the enumerator");
 742                 } catch (InvalidOperationException) {
 743                         // do nothing...this is what we expect
 744                 }
 745
 746                 en = al1.GetEnumerator();
 747                 en.MoveNext();
 748                 al1.RemoveAt(2);
 749                 try {
 750                         en.MoveNext();
 751                         Fail("RemoveAt() didn't invalidate the enumerator");
 752                 } catch (InvalidOperationException) {
 753                         // do nothing...this is what we expect
 754                 }
 755
 756                 en = al1.GetEnumerator();
 757                 en.MoveNext();
 758                 al1.RemoveRange(1, 1);
 759                 try {
 760                         en.MoveNext();
 761                         Fail("RemoveRange() didn't invalidate the enumerator");
 762                 } catch (InvalidOperationException) {
 763                         // do nothing...this is what we expect
 764                 }
 765
 766                 en = al1.GetEnumerator();
 767                 en.MoveNext();
 768                 al1.Reverse();
 769                 try {
 770                         en.MoveNext();
 771                         Fail("Reverse() didn't invalidate the enumerator");
 772                 } catch (InvalidOperationException) {
 773                         // do nothing...this is what we expect
 774                 }
 775
 776                 en = al1.GetEnumerator();
 777                 en.MoveNext();
 778                 al1.Sort();
 779                 try {
 780                         en.MoveNext();
 781                         Fail("Sort() didn't invalidate the enumerator");
 782                 } catch (InvalidOperationException) {
 783                         // do nothing...this is what we expect
 784                 }
 785         }
 786
 787         public void TestGetEnumerator() {
 788                 {
 789                         bool errorThrown = false;
 790                         try {
 791                                 ArrayList a = new ArrayList();
 792                                 IEnumerator en = a.GetEnumerator(-1,1);
 793                         } catch (ArgumentOutOfRangeException) {
 794                                 errorThrown = true;
 795                         }
 796                         Assert("negative index error not thrown",
 797                                errorThrown);
 798                 }
 799                 {
 800                         bool errorThrown = false;
 801                         try {
 802                                 ArrayList a = new ArrayList();
 803                                 IEnumerator en = a.GetEnumerator(1,-1);
 804                         } catch (ArgumentOutOfRangeException) {
 805                                 errorThrown = true;
 806                         }
 807                         Assert("negative index error not thrown",
 808                                errorThrown);
 809                 }
 810                 {
 811                         bool errorThrown = false;
 812                         try {
 813                                 ArrayList a = new ArrayList();
 814                                 IEnumerator en = a.GetEnumerator(1,1);
 815                         } catch (ArgumentException) {
 816                                 errorThrown = true;
 817                         }
 818                         Assert("out-of-range index error not thrown",
 819                                errorThrown);
 820                 }
 821                 {
 822                         String[] s1 = {"this", "is", "a", "test"};
 823                         ArrayList al1 = new ArrayList(s1);
 824                         IEnumerator en = al1.GetEnumerator();
 825                         AssertNotNull("No enumerator", en);
 826
 827                         for (int i = 0; i < s1.Length; i++) {
 828                                 en.MoveNext();
 829                                 AssertEquals("Not enumerating",
 830                                              al1[i], en.Current);
 831                         }
 832                 }
 833                 {
 834                         String[] s1 = {"this", "is", "a", "test"};
 835                         ArrayList al1 = new ArrayList(s1);
 836                         IEnumerator en = al1.GetEnumerator(1,2);
 837                         AssertNotNull("No enumerator", en);
 838
 839                         for (int i = 0; i < 2; i++) {
 840                                 en.MoveNext();
 841                                 AssertEquals("Not enumerating",
 842                                              al1[i+1], en.Current);
 843                         }
 844                 }
 845         }
 846
 847         [Test]
 848         [ExpectedException (typeof (ArgumentException))]
 849         public void GetEnumerator_IndexOverflow ()
 850         {
 851                 ArrayList al = new ArrayList ();
 852                 al.Add (this);
 853                 al.GetEnumerator (Int32.MaxValue, 0);
 854         }
 855
 856         [Test]
 857         [ExpectedException (typeof (ArgumentException))]
 858         public void GetEnumerator_CountOverflow ()
 859         {
 860                 ArrayList al = new ArrayList ();
 861                 al.Add (this);
 862                 al.GetEnumerator (0, Int32.MaxValue);
 863         }
 864
 865         public void TestGetRange() {
 866                 {
 867                         bool errorThrown = false;
 868                         try {
 869                                 ArrayList a = new ArrayList();
 870                                 ArrayList b = a.GetRange(-1,1);
 871                         } catch (ArgumentOutOfRangeException) {
 872                                 errorThrown = true;
 873                         }
 874                         Assert("negative index error not thrown",
 875                                errorThrown);
 876                 }
 877                 {
 878                         bool errorThrown = false;
 879                         try {
 880                                 ArrayList a = new ArrayList();
 881                                 ArrayList b = a.GetRange(1,-1);
 882                         } catch (ArgumentOutOfRangeException) {
 883                                 errorThrown = true;
 884                         }
 885                         Assert("negative index error not thrown",
 886                                errorThrown);
 887                 }
 888                 {
 889                         bool errorThrown = false;
 890                         try {
 891                                 ArrayList a = new ArrayList();
 892                                 ArrayList b = a.GetRange(1,1);
 893                         } catch (ArgumentException) {
 894                                 errorThrown = true;
 895                         }
 896                         Assert("out-of-range index error not thrown",
 897                                errorThrown);
 898                 }
 899                 {
 900                         char[] chars = {'a', 'b', 'c', 'd', 'e', 'f'};
 901                         ArrayList a = new ArrayList(chars);
 902                         ArrayList b = a.GetRange(1, 3);
 903                         AssertEquals("GetRange returned wrong size ArrayList", 3, b.Count);
 904                         for (int i = 0; i < b.Count; i++) {
 905                                 AssertEquals("range didn't work",
 906                                              chars[i+1], b[i]);
 907                         }
 908
 909                         a[2] = '?'; // should screw up ArrayList b.
 910                         bool errorThrown = false;
 911                         try {
 912                                 int i = b.Count;
 913                         } catch (InvalidOperationException) {
 914                                 errorThrown = true;
 915                         }
 916                         AssertEquals("Munging 'a' should mess up 'b'",
 917                                      true, errorThrown);
 918                 }
 919         }
 920
 921         [Test]
 922         [ExpectedException (typeof (ArgumentException))]
 923         public void GetRange_IndexOverflow ()
 924         {
 925                 ArrayList al = new ArrayList ();
 926                 al.Add (this);
 927                 al.GetRange (Int32.MaxValue, 0);
 928         }
 929
 930         [Test]
 931         [ExpectedException (typeof (ArgumentException))]
 932         public void GetRange_CountOverflow ()
 933         {
 934                 ArrayList al = new ArrayList ();
 935                 al.Add (this);
 936                 al.GetRange (0, Int32.MaxValue);
 937         }
 938
 939         public void TestIndexOf() {
 940                 {
 941                         bool errorThrown = false;
 942                         try {
 943                                 ArrayList a = new ArrayList(1);
 944                                 int i = a.IndexOf('a', -1);
 945                         } catch (ArgumentOutOfRangeException) {
 946                                 errorThrown = true;
 947                         }
 948                         Assert("negative indexof error not thrown",
 949                                errorThrown);
 950                 }
 951                 {
 952                         bool errorThrown = false;
 953                         try {
 954                                 ArrayList a = new ArrayList(1);
 955                                 int i = a.IndexOf('a', 2);
 956                         } catch (ArgumentOutOfRangeException) {
 957                                 errorThrown = true;
 958                         }
 959                         Assert("past-end indexof error not thrown",
 960                                errorThrown);
 961                 }
 962                 {
 963                         bool errorThrown = false;
 964                         try {
 965                                 ArrayList a = new ArrayList(1);
 966                                 int i = a.IndexOf('a', 0, -1);
 967                         } catch (ArgumentOutOfRangeException) {
 968                                 errorThrown = true;
 969                         }
 970                         Assert("negative indexof error not thrown",
 971                                errorThrown);
 972                 }
 973                 {
 974                         bool errorThrown = false;
 975                         try {
 976                                 ArrayList a = new ArrayList(1);
 977                                 int i = a.IndexOf('a', 0, 2);
 978                         } catch (ArgumentOutOfRangeException) {
 979                                 errorThrown = true;
 980                         }
 981                         Assert("past-end indexof error not thrown",
 982                                errorThrown);
 983                 }
 984                 {
 985                         bool errorThrown = false;
 986                         try {
 987                                 ArrayList a = new ArrayList(2);
 988                                 int i = a.IndexOf('a', 1, 2);
 989                         } catch (ArgumentOutOfRangeException) {
 990                                 errorThrown = true;
 991                         }
 992                         Assert("past-end indexof error not thrown",
 993                                errorThrown);
 994                 }
 995                 {
 996                         char[] c = {'a', 'b', 'c', 'd', 'e'};
 997                         ArrayList a = new ArrayList(c);
 998                         AssertEquals("never find null",
 999                                      -1, a.IndexOf(null));
1000                         AssertEquals("never find null",
1001                                      -1, a.IndexOf(null, 0));
1002                         AssertEquals("never find null",
1003                                      -1, a.IndexOf(null, 0, 5));
1004                         AssertEquals("can't find elem",
1005                                      2, a.IndexOf('c'));
1006                         AssertEquals("can't find elem",
1007                                      2, a.IndexOf('c', 2));
1008                         AssertEquals("can't find elem",
1009                                      2, a.IndexOf('c', 2, 2));
1010                         AssertEquals("shouldn't find elem",
1011                                      -1, a.IndexOf('c', 3, 2));
1012                         AssertEquals("shouldn't find", -1, a.IndexOf('?'));
1013                         AssertEquals("shouldn't find", -1, a.IndexOf(3));
1014                 }
1015         }
1016
1017         [Test]
1018         [ExpectedException (typeof (ArgumentOutOfRangeException))]
1019         public void IndexOf_StartIndexOverflow ()
1020         {
1021                 ArrayList al = new ArrayList ();
1022                 al.Add (this);
1023                 al.IndexOf ('a', Int32.MaxValue, 1);
1024         }
1025
1026         [Test]
1027         [ExpectedException (typeof (ArgumentOutOfRangeException))]
1028         public void IndexOf_CountOverflow ()
1029         {
1030                 ArrayList al = new ArrayList ();
1031                 al.Add (this);
1032                 al.IndexOf ('a', 1, Int32.MaxValue);
1033         }
1034
1035         public void TestInsert() {
1036                 {
1037                         bool errorThrown = false;
1038                         try {
1039                                 ArrayList al1 =
1040                                         ArrayList.FixedSize(new ArrayList());
1041                                 al1.Insert(0, "Hi!");
1042                         } catch (NotSupportedException) {
1043                                 errorThrown = true;
1044                         }
1045                         Assert("insert to fixed size error not thrown",
1046                                errorThrown);
1047                 }
1048                 {
1049                         bool errorThrown = false;
1050                         try {
1051                                 ArrayList al1 =
1052                                         ArrayList.ReadOnly(new ArrayList());
1053                                 al1.Insert(0, "Hi!");
1054                         } catch (NotSupportedException) {
1055                                 errorThrown = true;
1056                         }
1057                         Assert("insert to read only error not thrown",
1058                                errorThrown);
1059                 }
1060                 {
1061                         bool errorThrown = false;
1062                         try {
1063                                 ArrayList al1 = new ArrayList(3);
1064                                 al1.Insert(-1, "Hi!");
1065                         } catch (ArgumentOutOfRangeException) {
1066                                 errorThrown = true;
1067                         }
1068                         Assert("insert to read only error not thrown",
1069                                errorThrown);
1070                 }
1071                 {
1072                         bool errorThrown = false;
1073                         try {
1074                                 ArrayList al1 = new ArrayList(3);
1075                                 al1.Insert(4, "Hi!");
1076                         } catch (ArgumentOutOfRangeException) {
1077                                 errorThrown = true;
1078                         }
1079                         Assert("insert to read only error not thrown",
1080                                errorThrown);
1081                 }
1082                 {
1083                         ArrayList al1 = new ArrayList();
1084                         AssertEquals("arraylist starts empty", 0, al1.Count);
1085                         al1.Insert(0, 'a');
1086                         al1.Insert(1, 'b');
1087                         al1.Insert(0, 'c');
1088                         AssertEquals("arraylist needs stuff", 3, al1.Count);
1089                         AssertEquals("arraylist got stuff", 'c', al1[0]);
1090                         AssertEquals("arraylist got stuff", 'a', al1[1]);
1091                         AssertEquals("arraylist got stuff", 'b', al1[2]);
1092                 }
1093         }
1094
1095         public void TestInsertRange() {
1096                 {
1097                         bool errorThrown = false;
1098                         try {
1099                                 ArrayList al1 =
1100                                         ArrayList.FixedSize(new ArrayList());
1101                                 string[] s = {"Hi!"};
1102                                 al1.InsertRange(0, s);
1103                         } catch (NotSupportedException) {
1104                                 errorThrown = true;
1105                         }
1106                         Assert("insert to fixed size error not thrown",
1107                                errorThrown);
1108                 }
1109                 {
1110                         bool errorThrown = false;
1111                         try {
1112                                 ArrayList al1 =
1113                                         ArrayList.ReadOnly(new ArrayList());
1114                                 string[] s = {"Hi!"};
1115                                 al1.InsertRange(0, s);
1116                         } catch (NotSupportedException) {
1117                                 errorThrown = true;
1118                         }
1119                         Assert("insert to read only error not thrown",
1120                                errorThrown);
1121                 }
1122                 {
1123                         bool errorThrown = false;
1124                         try {
1125                                 ArrayList al1 = new ArrayList(3);
1126                                 string[] s = {"Hi!"};
1127                                 al1.InsertRange(-1, s);
1128                         } catch (ArgumentOutOfRangeException) {
1129                                 errorThrown = true;
1130                         }
1131                         Assert("negative index insert error not thrown",
1132                                errorThrown);
1133                 }
1134                 {
1135                         bool errorThrown = false;
1136                         try {
1137                                 ArrayList al1 = new ArrayList(3);
1138                                 string[] s = {"Hi!"};
1139                                 al1.InsertRange(4, s);
1140                         } catch (ArgumentOutOfRangeException) {
1141                                 errorThrown = true;
1142                         }
1143                         Assert("out-of-range insert error not thrown",
1144                                errorThrown);
1145                 }
1146                 {
1147                         bool errorThrown = false;
1148                         try {
1149                                 ArrayList al1 = new ArrayList(3);
1150                                 al1.InsertRange(0, null);
1151                         } catch (ArgumentNullException) {
1152                                 errorThrown = true;
1153                         }
1154                         Assert("null insert error not thrown",
1155                                errorThrown);
1156                 }
1157                 {
1158                         char[] c = {'a', 'b', 'c'};
1159                         ArrayList a = new ArrayList(c);
1160                         a.InsertRange(1, c);
1161                         AssertEquals("bad insert 1", 'a', a[0]);
1162                         AssertEquals("bad insert 2", 'a', a[1]);
1163                         AssertEquals("bad insert 3", 'b', a[2]);
1164                         AssertEquals("bad insert 4", 'c', a[3]);
1165                         AssertEquals("bad insert 5", 'b', a[4]);
1166                         AssertEquals("bad insert 6", 'c', a[5]);
1167                 }
1168         }
1169
1170         public void TestLastIndexOf() {
1171                 //{
1172                 //bool errorThrown = false;
1173                 //try {
1174                 //ArrayList a = new ArrayList(1);
1175                 //int i = a.LastIndexOf('a', -1);
1176                 //} catch (ArgumentOutOfRangeException) {
1177                 //errorThrown = true;
1178                 //}
1179                 //Assert("first negative lastindexof error not thrown",
1180                 //errorThrown);
1181                 //}
1182                 {
1183                         bool errorThrown = false;
1184                         try {
1185                                 ArrayList a = new ArrayList(1);
1186                                 int i = a.LastIndexOf('a', 2);
1187                         } catch (ArgumentOutOfRangeException) {
1188                                 errorThrown = true;
1189                         }
1190                         Assert("past-end lastindexof error not thrown",
1191                                errorThrown);
1192                 }
1193                 //{
1194                 //bool errorThrown = false;
1195                 //try {
1196                 //ArrayList a = new ArrayList(1);
1197                 //int i = a.LastIndexOf('a', 0, -1);
1198                 //} catch (ArgumentOutOfRangeException) {
1199                 //errorThrown = true;
1200                 //}
1201                 //Assert("second negative lastindexof error not thrown",
1202                 //errorThrown);
1203                 //}
1204                 //{
1205                 //bool errorThrown = false;
1206                 //try {
1207                 //ArrayList a = new ArrayList(1);
1208                 //int i = a.LastIndexOf('a', 0, 2);
1209                 //} catch (ArgumentOutOfRangeException) {
1210                 //errorThrown = true;
1211                 //}
1212                 //Assert("past-end lastindexof error not thrown",
1213                 //errorThrown);
1214                 //}
1215                 //{
1216                 //bool errorThrown = false;
1217                 //try {
1218                 //ArrayList a = new ArrayList(2);
1219                 //int i = a.LastIndexOf('a', 0, 2);
1220                 //} catch (ArgumentOutOfRangeException) {
1221                 //errorThrown = true;
1222                 //}
1223                 //Assert("past-end lastindexof error not thrown",
1224                 //errorThrown);
1225                 //}
1226                 int iTest = 0;
1227                 try {
1228                         char[] c = {'a', 'b', 'c', 'd', 'e'};
1229                         ArrayList a = new ArrayList(c);
1230                         AssertEquals("never find null",
1231                                      -1, a.LastIndexOf(null));
1232                         iTest++;
1233                         AssertEquals("never find null",
1234                                      -1, a.LastIndexOf(null, 4));
1235                         iTest++;
1236                         AssertEquals("never find null",
1237                                      -1, a.LastIndexOf(null, 4, 5));
1238                         iTest++;
1239                         AssertEquals("can't find elem",
1240                                      2, a.LastIndexOf('c'));
1241                         iTest++;
1242                         AssertEquals("can't find elem",
1243                                      2, a.LastIndexOf('c', 4));
1244                         iTest++;
1245                         AssertEquals("can't find elem",
1246                                      2, a.LastIndexOf('c', 3, 2));
1247                         iTest++;
1248                         AssertEquals("shouldn't find elem",
1249                                      -1, a.LastIndexOf('c', 4, 2));
1250                         iTest++;
1251                         AssertEquals("shouldn't find", -1, a.LastIndexOf('?'));
1252                         iTest++;
1253                         AssertEquals("shouldn't find", -1, a.LastIndexOf(1));
1254                 } catch (Exception e) {
1255                         Fail ("Unexpected exception caught when iTest=" + iTest + ". e=" + e);
1256                 }
1257         }
1258
1259         [Test]
1260         [ExpectedException (typeof (ArgumentOutOfRangeException))]
1261         public void LastIndexOf_StartIndexOverflow ()
1262         {
1263                 ArrayList al = new ArrayList ();
1264                 al.Add (this);
1265                 al.LastIndexOf ('a', Int32.MaxValue, 1);
1266         }
1267
1268         [Test]
1269         [ExpectedException (typeof (ArgumentOutOfRangeException))]
1270         public void LastIndexOf_CountOverflow ()
1271         {
1272                 ArrayList al = new ArrayList ();
1273                 al.Add (this);
1274                 al.LastIndexOf ('a', 1, Int32.MaxValue);
1275         }
1276
1277         public void TestReadOnly() {
1278                 {
1279                         bool errorThrown = false;
1280                         try {
1281                                 ArrayList al1 = ArrayList.ReadOnly(null);
1282                         } catch (ArgumentNullException) {
1283                                 errorThrown = true;
1284                         }
1285                         Assert("null arg error not thrown", errorThrown);
1286                 }
1287                 {
1288                         ArrayList al1 = new ArrayList();
1289                         AssertEquals("arrays start writeable.",
1290                                      false, al1.IsReadOnly);
1291                         ArrayList al2 = ArrayList.ReadOnly(al1);
1292                         AssertEquals("should be readonly.",
1293                                      true, al2.IsReadOnly);
1294                 }
1295         }
1296
1297         public void TestRemove() {
1298                 {
1299                         bool errorThrown = false;
1300                         try {
1301                                 ArrayList al1 =
1302                                         ArrayList.FixedSize(new ArrayList(3));
1303                                 al1.Remove(1);
1304                         } catch (NotSupportedException) {
1305                                 errorThrown = true;
1306                         }
1307                         Assert("remove fixed size error not thrown",
1308                                errorThrown);
1309                 }
1310                 {
1311                         bool errorThrown = false;
1312                         try {
1313                                 ArrayList al1 =
1314                                         ArrayList.ReadOnly(new ArrayList(3));
1315                                 al1.Remove(1);
1316                         } catch (NotSupportedException) {
1317                                 errorThrown = true;
1318                         }
1319                         Assert("remove read only error not thrown",
1320                                errorThrown);
1321                 }
1322                 {
1323                         char[] c = {'a','b','c'};
1324                         ArrayList a = new ArrayList(c);
1325                         a.Remove(1);
1326                         a.Remove('?');
1327                         AssertEquals("should be unchanged", c.Length, a.Count);
1328                         a.Remove('a');
1329                         AssertEquals("should be changed", 2, a.Count);
1330                         AssertEquals("should have shifted", 'b', a[0]);
1331                         AssertEquals("should have shifted", 'c', a[1]);
1332                 }
1333         }
1334
1335         public void TestRemoveAt() {
1336                 {
1337                         bool errorThrown = false;
1338                         try {
1339                                 ArrayList al1 =
1340                                         ArrayList.FixedSize(new ArrayList(3));
1341                                 al1.RemoveAt(1);
1342                         } catch (NotSupportedException) {
1343                                 errorThrown = true;
1344                         }
1345                         Assert("remove from fixed size error not thrown",
1346                                errorThrown);
1347                 }
1348                 {
1349                         bool errorThrown = false;
1350                         try {
1351                                 ArrayList al1 =
1352                                         ArrayList.ReadOnly(new ArrayList(3));
1353                                 al1.RemoveAt(1);
1354                         } catch (NotSupportedException) {
1355                                 errorThrown = true;
1356                         }
1357                         Assert("remove from read only error not thrown",
1358                                errorThrown);
1359                 }
1360                 {
1361                         bool errorThrown = false;
1362                         try {
1363                                 ArrayList al1 = new ArrayList(3);
1364                                 al1.RemoveAt(-1);
1365                         } catch (ArgumentOutOfRangeException) {
1366                                 errorThrown = true;
1367                         }
1368                         Assert("remove at negative index error not thrown",
1369                                errorThrown);
1370                 }
1371                 {
1372                         bool errorThrown = false;
1373                         try {
1374                                 ArrayList al1 = new ArrayList(3);
1375                                 al1.RemoveAt(4);
1376                         } catch (ArgumentOutOfRangeException) {
1377                                 errorThrown = true;
1378                         }
1379                         Assert("remove at out-of-range index error not thrown",
1380                                errorThrown);
1381                 }
1382                 {
1383                         char[] c = {'a','b','c'};
1384                         ArrayList a = new ArrayList(c);
1385                         a.RemoveAt(0);
1386                         AssertEquals("should be changed", 2, a.Count);
1387                         AssertEquals("should have shifted", 'b', a[0]);
1388                         AssertEquals("should have shifted", 'c', a[1]);
1389                 }
1390         }
1391
1392         public void TestRemoveRange() {
1393                 {
1394                         bool errorThrown = false;
1395                         try {
1396                                 ArrayList al1 =
1397                                         ArrayList.FixedSize(new ArrayList(3));
1398                                 al1.RemoveRange(0, 1);
1399                         } catch (NotSupportedException) {
1400                                 errorThrown = true;
1401                         }
1402                         Assert("removerange from fixed size error not thrown",
1403                                errorThrown);
1404                 }
1405                 {
1406                         bool errorThrown = false;
1407                         try {
1408                                 ArrayList al1 =
1409                                         ArrayList.ReadOnly(new ArrayList(3));
1410                                 al1.RemoveRange(0, 1);
1411                         } catch (NotSupportedException) {
1412                                 errorThrown = true;
1413                         }
1414                         Assert("removerange from read only error not thrown",
1415                                errorThrown);
1416                 }
1417                 {
1418                         bool errorThrown = false;
1419                         try {
1420                                 ArrayList al1 = new ArrayList(3);
1421                                 al1.RemoveRange(-1, 1);
1422                         } catch (ArgumentOutOfRangeException) {
1423                                 errorThrown = true;
1424                         }
1425                         Assert("removerange at negative index error not thrown",
1426                                errorThrown);
1427                 }
1428                 {
1429                         bool errorThrown = false;
1430                         try {
1431                                 ArrayList al1 = new ArrayList(3);
1432                                 al1.RemoveRange(0, -1);
1433                         } catch (ArgumentOutOfRangeException) {
1434                                 errorThrown = true;
1435                         }
1436                         Assert("removerange at negative index error not thrown",
1437                                errorThrown);
1438                 }
1439                 {
1440                         bool errorThrown = false;
1441                         try {
1442                                 ArrayList al1 = new ArrayList(3);
1443                                 al1.RemoveRange(2, 3);
1444                         } catch (ArgumentException) {
1445                                 errorThrown = true;
1446                         }
1447                         Assert("removerange at bad range error not thrown",
1448                                errorThrown);
1449                 }
1450                 {
1451                         char[] c = {'a','b','c'};
1452                         ArrayList a = new ArrayList(c);
1453                         a.RemoveRange(1,2);
1454                         AssertEquals("should be changed", 1, a.Count);
1455                         AssertEquals("should have shifted", 'a', a[0]);
1456                 }
1457         }
1458
1459         [Test]
1460         [ExpectedException (typeof (ArgumentException))]
1461         public void RemoveRange_IndexOverflow ()
1462         {
1463                 ArrayList al = new ArrayList ();
1464                 al.Add (this);
1465                 al.RemoveRange (Int32.MaxValue, 1);
1466         }
1467
1468         [Test]
1469         [ExpectedException (typeof (ArgumentException))]
1470         public void RemoveRange_CountOverflow ()
1471         {
1472                 ArrayList al = new ArrayList ();
1473                 al.Add (this);
1474                 al.RemoveRange (1, Int32.MaxValue);
1475         }
1476
1477         public void TestRepeat() {
1478                 {
1479                         bool errorThrown = false;
1480                         try {
1481                                 ArrayList al1 = ArrayList.Repeat('c', -1);
1482                         } catch (ArgumentOutOfRangeException) {
1483                                 errorThrown = true;
1484                         }
1485                         Assert("repeat negative copies error not thrown",
1486                                errorThrown);
1487                 }
1488                 {
1489                         ArrayList al1 = ArrayList.Repeat("huh?", 0);
1490                         AssertEquals("should be nothing in array",
1491                                      0, al1.Count);
1492                 }
1493                 {
1494                         ArrayList al1 = ArrayList.Repeat("huh?", 3);
1495                         AssertEquals("should be something in array",
1496                                      3, al1.Count);
1497                         AssertEquals("array elem doesn't check",
1498                                      "huh?", al1[0]);
1499                         AssertEquals("array elem doesn't check",
1500                                      "huh?", al1[1]);
1501                         AssertEquals("array elem doesn't check",
1502                                      "huh?", al1[2]);
1503                 }
1504         }
1505
1506         public void TestReverse() {
1507                 {
1508                         bool errorThrown = false;
1509                         try {
1510                                 ArrayList al1 =
1511                                         ArrayList.ReadOnly(new ArrayList());
1512                                 al1.Reverse();
1513                         } catch (NotSupportedException) {
1514                                 errorThrown = true;
1515                         }
1516                         Assert("reverse on read only error not thrown",
1517                                errorThrown);
1518                 }
1519                 {
1520                         bool errorThrown = false;
1521                         try {
1522                                 char[] c = new Char[2];
1523                                 ArrayList al1 = new ArrayList(c);
1524                                 al1.Reverse(0, 3);
1525                         } catch (ArgumentException) {
1526                                 errorThrown = true;
1527                         }
1528                         Assert("error not thrown", errorThrown);
1529                 }
1530                 {
1531                         bool errorThrown = false;
1532                         try {
1533                                 char[] c = new Char[2];
1534                                 ArrayList al1 = new ArrayList(c);
1535                                 al1.Reverse(3, 0);
1536                         } catch (ArgumentException) {
1537                                 errorThrown = true;
1538                         }
1539                         Assert("error not thrown", errorThrown);
1540                 }
1541                 {
1542                         char[] c = {'a', 'b', 'c', 'd', 'e'};
1543                         ArrayList al1 = new ArrayList(c);
1544                         al1.Reverse(2,1);
1545                         for (int i = 0; i < al1.Count; i++) {
1546                                 AssertEquals("Should be no change yet",
1547                                              c[i], al1[i]);
1548                         }
1549                         al1.Reverse();
1550                         for (int i = 0; i < al1.Count; i++) {
1551                                 AssertEquals("Should be reversed",
1552                                              c[i], al1[4-i]);
1553                         }
1554                         al1.Reverse();
1555                         for (int i = 0; i < al1.Count; i++) {
1556                                 AssertEquals("Should be back to normal",
1557                                              c[i], al1[i]);
1558                         }
1559                         al1.Reverse(1,3);
1560                         AssertEquals("Should be back to normal", c[0], al1[0]);
1561                         AssertEquals("Should be back to normal", c[3], al1[1]);
1562                         AssertEquals("Should be back to normal", c[2], al1[2]);
1563                         AssertEquals("Should be back to normal", c[1], al1[3]);
1564                         AssertEquals("Should be back to normal", c[4], al1[4]);
1565                 }
1566         }
1567
1568         [Test]
1569         [ExpectedException (typeof (ArgumentException))]
1570         public void Reverse_IndexOverflow ()
1571         {
1572                 ArrayList al = new ArrayList ();
1573                 al.Add (this);
1574                 al.Reverse (Int32.MaxValue, 1);
1575         }
1576
1577         [Test]
1578         [ExpectedException (typeof (ArgumentException))]
1579         public void Reverse_CountOverflow ()
1580         {
1581                 ArrayList al = new ArrayList ();
1582                 al.Add (this);
1583                 al.Reverse (1, Int32.MaxValue);
1584         }
1585
1586         public void TestSetRange() {
1587                 {
1588                         bool errorThrown = false;
1589                         try {
1590                                 char[] c = {'a', 'b', 'c'};
1591                                 ArrayList al1 =
1592                                         ArrayList.ReadOnly(new ArrayList(3));
1593                                 al1.SetRange(0, c);
1594                         } catch (NotSupportedException) {
1595                                 errorThrown = true;
1596                         } catch (Exception e) {
1597                                 Fail ("Incorrect exception thrown at 1: " + e.ToString());
1598                         }
1599                         Assert("setrange on read only error not thrown",
1600                                errorThrown);
1601                 }
1602                 {
1603                         bool errorThrown = false;
1604                         try {
1605                                 ArrayList al1 = new ArrayList(3);
1606                                 al1.SetRange(0, null);
1607                         } catch (ArgumentNullException) {
1608                                 errorThrown = true;
1609                         } catch (ArgumentOutOfRangeException) {
1610                                 errorThrown = true;
1611                         } catch (Exception e) {
1612                                 Fail ("Incorrect exception thrown at 2: " + e.ToString());
1613                         }
1614                         Assert("setrange with null error not thrown",
1615                                errorThrown);
1616                 }
1617                 {
1618                         bool errorThrown = false;
1619                         try {
1620                                 char[] c = {'a', 'b', 'c'};
1621                                 ArrayList al1 = new ArrayList(3);
1622                                 al1.SetRange(-1, c);
1623                         } catch (ArgumentOutOfRangeException) {
1624                                 errorThrown = true;
1625                         } catch (Exception e) {
1626                                 Fail ("Incorrect exception thrown at 3: " + e.ToString());
1627                         }
1628                         Assert("setrange with negative index error not thrown",
1629                                errorThrown);
1630                 }
1631                 {
1632                         bool errorThrown = false;
1633                         try {
1634                                 char[] c = {'a', 'b', 'c'};
1635                                 ArrayList al1 = new ArrayList(3);
1636                                 al1.SetRange(2, c);
1637                         } catch (ArgumentOutOfRangeException) {
1638                                 errorThrown = true;
1639                         } catch (Exception e) {
1640                                 Fail ("Incorrect exception thrown at 4: " + e.ToString());
1641                         }
1642                         Assert("setrange with too much error not thrown",
1643                                errorThrown);
1644                 }
1645
1646                 {
1647                         char[] c = {'a', 'b', 'c'};
1648                         ArrayList al1 = ArrayList.Repeat('?', 3);
1649                         Assert("no match yet", c[0] != (char)al1[0]);
1650                         Assert("no match yet", c[1] != (char)al1[1]);
1651                         Assert("no match yet", c[2] != (char)al1[2]);
1652                         al1.SetRange(0, c);
1653                         AssertEquals("should match", c[0], al1[0]);
1654                         AssertEquals("should match", c[1], al1[1]);
1655                         AssertEquals("should match", c[2], al1[2]);
1656                 }
1657         }
1658
1659         [Test]
1660         [ExpectedException (typeof (ArgumentOutOfRangeException))]
1661         public void SetRange_Overflow ()
1662         {
1663                 ArrayList al = new ArrayList ();
1664                 al.Add (this);
1665                 al.SetRange (Int32.MaxValue, new ArrayList ());
1666         }
1667
1668         public void TestInsertRange_this() {
1669                 String[] s1 = {"this", "is", "a", "test"};
1670                 ArrayList al = new ArrayList(s1);
1671                 al.InsertRange(2, al);
1672                 String[] s2 = {"this", "is", "this", "is", "a", "test", "a", "test"};
1673                 for (int i=0; i < al.Count; i++) {
1674                         AssertEquals("at i=" + i, s2[i], al[i]);
1675                 }
1676         }
1677
1678         public void TestSort() {
1679                 {
1680                         bool errorThrown = false;
1681                         try {
1682                                 ArrayList al1 =
1683                                         ArrayList.ReadOnly(new ArrayList());
1684                                 al1.Sort();
1685                         } catch (NotSupportedException) {
1686                                 errorThrown = true;
1687                         }
1688                         Assert("sort on read only error not thrown",
1689                                errorThrown);
1690                 }
1691                 {
1692                         char[] starter = {'d', 'b', 'f', 'e', 'a', 'c'};
1693                         ArrayList al1 = new ArrayList(starter);
1694                         al1.Sort();
1695                         AssertEquals("Should be sorted", 'a', al1[0]);
1696                         AssertEquals("Should be sorted", 'b', al1[1]);
1697                         AssertEquals("Should be sorted", 'c', al1[2]);
1698                         AssertEquals("Should be sorted", 'd', al1[3]);
1699                         AssertEquals("Should be sorted", 'e', al1[4]);
1700                         AssertEquals("Should be sorted", 'f', al1[5]);
1701                 }
1702                 {
1703                         ArrayList al1 = new ArrayList ();
1704                         al1.Add (null);
1705                         al1.Add (null);
1706                         al1.Add (32);
1707                         al1.Add (33);
1708                         al1.Add (null);
1709                         al1.Add (null);
1710
1711                         al1.Sort ();
1712                         AssertEquals ("Should be null", null, al1 [0]);
1713                         AssertEquals ("Should be 2. null", null, al1 [1]);
1714                         AssertEquals ("Should be 3. null", null, al1 [2]);
1715                         AssertEquals ("Should be 4. null", null, al1 [3]);
1716                         AssertEquals ("Should be 32", 32, al1 [4]);
1717                         AssertEquals ("Should be 33", 33, al1 [5]);
1718                 }
1719         }
1720
1721         [Test]
1722         [ExpectedException (typeof (ArgumentException))]
1723         public void Sort_IndexOverflow ()
1724         {
1725                 ArrayList al = new ArrayList ();
1726                 al.Add (this);
1727                 al.Sort (Int32.MaxValue, 1, null);
1728         }
1729
1730         [Test]
1731         [ExpectedException (typeof (ArgumentException))]
1732         public void Sort_CountOverflow ()
1733         {
1734                 ArrayList al = new ArrayList ();
1735                 al.Add (this);
1736                 al.Sort (1, Int32.MaxValue, null);
1737         }
1738
1739         // TODO - Sort with IComparers
1740
1741         // TODO - Synchronize
1742
1743         public void TestToArray() {
1744                 {
1745                         bool errorThrown = false;
1746                         try {
1747                                 ArrayList al1 = new ArrayList(3);
1748                                 al1.ToArray(null);
1749                         } catch (ArgumentNullException) {
1750                                 errorThrown = true;
1751                         }
1752                         Assert("toarray with null error not thrown",
1753                                errorThrown);
1754                 }
1755                 {
1756                         bool errorThrown = false;
1757                         try {
1758                                 char[] c = {'a', 'b', 'c'};
1759                                 string s = "huh?";
1760                                 ArrayList al1 = new ArrayList(c);
1761                                 al1.ToArray(s.GetType());
1762                         } catch (InvalidCastException) {
1763                                 errorThrown = true;
1764                         }
1765                         Assert("toarray with bad type error not thrown",
1766                                errorThrown);
1767                 }
1768                 {
1769                         char[] c1 = {'a', 'b', 'c', 'd', 'e'};
1770                         ArrayList al1 = new ArrayList(c1);
1771                         object[] o2 = al1.ToArray();
1772                         for (int i = 0; i < c1.Length; i++) {
1773                                 AssertEquals("should be copy", c1[i], o2[i]);
1774                         }
1775                         Array c2 = al1.ToArray(c1[0].GetType());
1776                         for (int i = 0; i < c1.Length; i++) {
1777                                 AssertEquals("should be copy",
1778                                              c1[i], c2.GetValue(i));
1779                         }
1780                 }
1781         }
1782
1783         public void TestTrimToSize() {
1784                 {
1785                         bool errorThrown = false;
1786                         try {
1787                                 ArrayList al1 =
1788                                         ArrayList.ReadOnly(new ArrayList());
1789                                 al1.TrimToSize();
1790                         } catch (NotSupportedException) {
1791                                 errorThrown = true;
1792                         }
1793                         Assert("trim read only error not thrown",
1794                                errorThrown);
1795                 }
1796                 {
1797                         ArrayList al1 = new ArrayList();
1798                         int capacity = al1.Capacity;
1799                         int size = capacity / 2;
1800                         for (int i = 1; i <=size; i++) {
1801                                 al1.Add('?');
1802                         }
1803                         al1.RemoveAt(0);
1804                         al1.TrimToSize();
1805                         AssertEquals("no capacity match",
1806                                      size - 1, al1.Capacity);
1807
1808                         al1.Clear();
1809                         al1.TrimToSize();
1810                         AssertEquals("no default capacity",
1811                                      capacity, al1.Capacity);
1812                 }
1813         }
1814
1815 }
1816
1817 }