mcs/class/corlib/Test/System/ArrayTest.cs

   1 // ArrayTest.cs - NUnit Test Cases for the System.Array class
   2 //
   3 // David Brandt (bucky@keystreams.com)
   4 // Eduardo Garcia (kiwnix@yahoo.es)
   5 //
   6 // (C) Ximian, Inc.  http://www.ximian.com
   7 // Copyright (C) 2004 Novell (http://www.novell.com)
   8 //
   9
  10 using NUnit.Framework;
  11 using System;
  12 using System.Collections;
  13 using System.Globalization;
  14 using System.Reflection;
  15 using System.Collections.Generic;
  16
  17 namespace MonoTests.System
  18 {
  19         //Auxiliary Things
  20         enum enua  {hola,adios,mas,menos};
  21
  22         class AClass
  23         {
  24                 public AClass()
  25                 {
  26
  27                 }
  28         }
  29
  30         class BClass : AClass
  31         {
  32         }
  33
  34         class CClass : AClass
  35         {
  36         }
  37
  38         struct AStruct
  39         {
  40                 public string s;
  41                 public string a;
  42         }
  43
  44         class DataEqual
  45         {
  46                 public override bool Equals (object obj)
  47                 {
  48                         return true;
  49                 }
  50
  51                 public override int GetHashCode ()
  52                 {
  53                         return 0;
  54                 }
  55         }
  56
  57         //End Auxiliary Things
  58
  59 [TestFixture]
  60 public class ArrayTest
  61 {
  62         char [] arrsort = {'d', 'b', 'f', 'e', 'a', 'c'};
  63
  64         public ArrayTest() {}
  65
  66         [Test]
  67         public void TestIsFixedSize() {
  68                 char[] a1 = {'a'};
  69                 Assert.IsTrue (a1.IsFixedSize, "All arrays are fixed");
  70         }
  71
  72         [Test]
  73         public void TestIsReadOnly() {
  74                 char[] a1 = {'a'};
  75                 Assert.IsTrue (!a1.IsReadOnly, "No array is readonly");
  76         }
  77
  78         [Test]
  79         public void TestIsSynchronized() {
  80                 char[] a1 = {'a'};
  81                 Assert.IsTrue (!a1.IsSynchronized, "No array is synchronized");
  82         }
  83
  84         [Test]
  85         public void TestLength() {
  86                 {
  87                         char[] a1 = { };
  88                         Assert.AreEqual (0, a1.Length, "Zero length array");
  89                 }
  90                 {
  91                         char[] a1 = {'c'};
  92                         Assert.AreEqual (1, a1.Length, "One-length array");
  93                 }
  94                 {
  95                         char[] a1 = {'c', 'c'};
  96                         Assert.AreEqual (2, a1.Length, "Two-length array");
  97                 }
  98         }
  99
 100         [Test]
 101         public void TestRank() {
 102                 char[] a1 = { 'c', 'd', 'e' };
 103                 Assert.AreEqual (1, a1.Rank, "Rank one");
 104
 105                 char[,] a2 = new Char[3,3];
 106                 Assert.AreEqual (2, a2.Rank, "Rank two");
 107
 108                 char[,,] a3 = new Char[3,3,3];
 109                 Assert.AreEqual (3, a3.Rank, "Rank three");
 110         }
 111
 112         [Test]
 113         public void TestBinarySearch1() {
 114                 bool errorThrown = false;
 115                 try {
 116                         Array.BinarySearch(null, "blue");
 117                 } catch (ArgumentNullException) {
 118                         errorThrown = true;
 119                 }
 120                 Assert.IsTrue (errorThrown, "#B01");
 121                 errorThrown = false;
 122                 try {
 123                         char[,] c1 = new Char[2,2];
 124                         Array.BinarySearch(c1, "needle");
 125                 } catch (RankException) {
 126                         errorThrown = true;
 127                 }
 128                 Assert.IsTrue (errorThrown, "#B02");
 129
 130                 {
 131                         char[] arr = {'a', 'b', 'b', 'c', 'c', 'c', 'd', 'd'};
 132                         Assert.IsTrue (Array.BinarySearch(arr, 'c') >= 3, "#B05");
 133                         Assert.IsTrue (Array.BinarySearch(arr, 'c') < 6, "#B06");
 134                 }
 135                 {
 136                         char[] arr = {'a', 'b', 'b', 'd', 'd', 'd', 'e', 'e'};
 137                         Assert.AreEqual (-4, Array.BinarySearch(arr, 'c'), "#B07");
 138                 }
 139                 {
 140                         char[] arr = {'a', 'b', 'b', 'c', 'c', 'c', 'd', 'd'};
 141                         Assert.AreEqual (-9, Array.BinarySearch(arr, 'e'), "#B08");
 142                 }
 143         }
 144
 145         [Test]
 146         public void TestBinarySearch2() {
 147                 bool errorThrown = false;
 148                 try {
 149                         Array.BinarySearch(null, 0, 1, "blue");
 150                 } catch (ArgumentNullException) {
 151                         errorThrown = true;
 152                 }
 153                 Assert.IsTrue (errorThrown, "#B20");
 154                 errorThrown = false;
 155                 try {
 156                         char[,] c1 = new Char[2,2];
 157                         Array.BinarySearch(c1, 0, 1, "needle");
 158                 } catch (RankException) {
 159                         errorThrown = true;
 160                 }
 161                 Assert.IsTrue (errorThrown, "#B21");
 162                 errorThrown = false;
 163                 try {
 164                         char[] c1 = {'a'};
 165                         Array.BinarySearch(c1, -1, 1, 'a');
 166                 } catch (ArgumentOutOfRangeException) {
 167                         errorThrown = true;
 168                 }
 169                 Assert.IsTrue (errorThrown, "#B22");
 170                 errorThrown = false;
 171                 try {
 172                         char[] c1 = {'a'};
 173                         Array.BinarySearch(c1, 0, -1, 'a');
 174                 } catch (ArgumentOutOfRangeException) {
 175                         errorThrown = true;
 176                 }
 177                 Assert.IsTrue (errorThrown, "#B23");
 178                 errorThrown = false;
 179                 try {
 180                         char[] c1 = {'a'};
 181                         Array.BinarySearch(c1, 0, 4, 'a');
 182                 } catch (ArgumentException) {
 183                         errorThrown = true;
 184                 }
 185                 Assert.IsTrue (errorThrown, "#B24");
 186
 187                 {
 188                         char[] arr = {'z', 'z', 'a', 'b', 'b', 'c', 'c', 'c', 'd', 'd'};
 189                         Assert.IsTrue (Array.BinarySearch(arr, 2, 8, 'c') >= 5, "#B26");
 190                         Assert.IsTrue (Array.BinarySearch(arr, 2, 8, 'c') < 8, "#B27");
 191                 }
 192                 {
 193                         char[] arr = {'z', 'z', 'a', 'b', 'b', 'd', 'd', 'd', 'e', 'e'};
 194                         Assert.AreEqual (-6, Array.BinarySearch(arr, 2, 8, 'c'), "#B28");
 195                 }
 196                 {
 197                         char[] arr = {'z', 'z', 'a', 'b', 'b', 'c', 'c', 'c', 'd', 'd'};
 198                         Assert.AreEqual (-11, Array.BinarySearch(arr, 2, 8, 'e'), "#B29");
 199                 }
 200         }
 201
 202         public void TestBinarySearch3()
 203         {
 204                 int[] array = new int[100];
 205
 206                 for (int i = 0; i < 100; i++)
 207                         array[i] = 10;
 208
 209                 Assert.AreEqual (49, Array.BinarySearch(array, 10), "#B30");
 210         }
 211
 212         [Test]
 213         public void BinarySearch_NullValue ()
 214         {
 215                 int[] array = new int[1];
 216                 Assert.AreEqual (-1, Array.BinarySearch (array, null), "I=a,o");
 217                 Assert.AreEqual (-1, Array.BinarySearch (array, null, null), "I=a,o,c");
 218                 Assert.AreEqual (-1, Array.BinarySearch (array, 0, 1, null), "I=a,i,i,o");
 219                 Assert.AreEqual (-1, Array.BinarySearch (array, 0, 1, null, null), "I=a,i,i,o,c");
 220
 221                 object[] o = new object [3] { this, this, null };
 222                 Assert.AreEqual (-1, Array.BinarySearch (o, null), "O=a,o");
 223                 Assert.AreEqual (-1, Array.BinarySearch (o, null, null), "O=a,o,c");
 224                 Assert.AreEqual (-1, Array.BinarySearch (o, 0, 3, null), "O=a,i,i,o");
 225                 Assert.AreEqual (-1, Array.BinarySearch (o, 0, 3, null, null), "O=a,i,i,o,c");
 226         }
 227
 228         class TestComparer7 : IComparer<int>
 229         {
 230                 public int Compare (int x, int y)
 231                 {
 232                         if (y != 7)
 233                                 throw new ApplicationException ();
 234
 235                         return x.CompareTo (y);
 236                 }
 237         }
 238
 239         [Test]
 240         public void BinarySearch_WithComparer ()
 241         {
 242                 var a = new int[] { 2, 6, 9 };
 243                 Assert.AreEqual (-3, Array.BinarySearch (a, 7, new TestComparer7 ()));
 244         }
 245
 246         [Test]
 247         public void TestClear() {
 248                 bool errorThrown = false;
 249                 try {
 250                         Array.Clear(null, 0, 1);
 251                 } catch (ArgumentNullException) {
 252                         errorThrown = true;
 253                 }
 254                 Assert.IsTrue (errorThrown, "#C01");
 255
 256                 int[] i1 = { 1, 2, 3, 4 };
 257                 {
 258                         int[] compare = {1,2,3,4};
 259                         Assert.AreEqual (compare[0], i1[0], "#C02");
 260                         Assert.AreEqual (compare[1], i1[1], "#C03");
 261                         Assert.AreEqual (compare[2], i1[2], "#C04");
 262                         Assert.AreEqual (compare[3], i1[3], "#C05");
 263                 }
 264                 Array.Clear(i1, 3, 1);
 265                 {
 266                         int[] compare = {1,2,3,0};
 267                         Assert.AreEqual (compare[0], i1[0], "#C06");
 268                         Assert.AreEqual (compare[1], i1[1], "#C07");
 269                         Assert.AreEqual (compare[2], i1[2], "#C08");
 270                         Assert.AreEqual (compare[3], i1[3], "#C09");
 271                 }
 272                 Array.Clear(i1, 1, 1);
 273                 {
 274                         int[] compare = {1,0,3,0};
 275                         Assert.AreEqual (compare[0], i1[0], "#C10");
 276                         Assert.AreEqual (compare[1], i1[1], "#C11");
 277                         Assert.AreEqual (compare[2], i1[2], "#C12");
 278                         Assert.AreEqual (compare[3], i1[3], "#C13");
 279                 }
 280                 Array.Clear(i1, 1, 3);
 281                 {
 282                         int[] compare = {1,0,0,0};
 283                         Assert.AreEqual (compare[0], i1[0], "#C14");
 284                         Assert.AreEqual (compare[1], i1[1], "#C15");
 285                         Assert.AreEqual (compare[2], i1[2], "#C16");
 286                         Assert.AreEqual (compare[3], i1[3], "#C17");
 287                 }
 288
 289                 string[] s1 = { "red", "green", "blue" };
 290                 Array.Clear(s1, 0, 3);
 291                 {
 292                         string[] compare = {null, null, null};
 293                         Assert.AreEqual (compare[0], s1[0], "#C18");
 294                         Assert.AreEqual (compare[1], s1[1], "#C19");
 295                         Assert.AreEqual (compare[2], s1[2], "#C20");
 296                 }
 297         }
 298
 299         [Test]
 300         public void TestClone() {
 301                 char[] c1 = {'a', 'b', 'c'};
 302                 char[] c2 = (char[])c1.Clone();
 303                 Assert.AreEqual (c1[0], c2[0], "#D01");
 304                 Assert.AreEqual (c1[1], c2[1], "#D02");
 305                 Assert.AreEqual (c1[2], c2[2], "#D03");
 306
 307                 char[] d10 = {'a', 'b'};
 308                 char[] d11 = {'a', 'c'};
 309                 char[] d12 = {'b', 'c'};
 310                 char[][] d1 = {d10, d11, d12};
 311                 char[][] d2 = (char[][])d1.Clone();
 312                 Assert.AreEqual (d1[0], d2[0], "#D04");
 313                 Assert.AreEqual (d1[1], d2[1], "#D05");
 314                 Assert.AreEqual (d1[2], d2[2], "#D06");
 315
 316                 d1[0][0] = 'z';
 317                 Assert.AreEqual (d1[0], d2[0], "#D07");
 318         }
 319
 320         [Test]
 321         public void TestMemberwiseClone () {
 322                 int[] array = new int[] { 1, 2, 3 };
 323                 MethodBase mi = array.GetType ().GetMethod("MemberwiseClone",
 324                                                                                                    BindingFlags.Instance | BindingFlags.NonPublic);
 325                 int[] res = (int[])mi.Invoke (array, null);
 326                 Assert.AreEqual (3, res.Length);
 327         }
 328
 329         [Test] public void TestIndexer ()
 330         {
 331                 int [] a = new int [10];
 332                 IList b = a;
 333                 try {
 334                         object c = b [-1];
 335                         Assert.Fail ("IList.this [-1] should throw");
 336                 } catch (IndexOutOfRangeException) {
 337                         // Good
 338                 } catch (Exception){
 339                         Assert.Fail ("Should have thrown an IndexOutOfRangeException");
 340                 }
 341         }
 342
 343         [Test]
 344         public void TestCopy() {
 345                 {
 346                         bool errorThrown = false;
 347                         try {
 348                                 Char[] c1 = {};
 349                                 Array.Copy(c1, null, 1);
 350                         } catch (ArgumentNullException) {
 351                                 errorThrown = true;
 352                         }
 353                         Assert.IsTrue (errorThrown, "#E01");
 354                 }
 355                 {
 356                         bool errorThrown = false;
 357                         try {
 358                                 Char[] c1 = {};
 359                                 Array.Copy(null, c1, 1);
 360                         } catch (ArgumentNullException) {
 361                                 errorThrown = true;
 362                         }
 363                         Assert.IsTrue (errorThrown, "#E02");
 364                 }
 365                 {
 366                         bool errorThrown = false;
 367                         try {
 368                                 Char[] c1 = new Char[1];
 369                                 Char[,] c2 = new Char[1,1];
 370                                 Array.Copy(c1, c2, 1);
 371                         } catch (RankException) {
 372                                 errorThrown = true;
 373                         }
 374                         Assert.IsTrue (errorThrown, "#E03");
 375                 }
 376                 {
 377                         bool errorThrown = false;
 378                         try {
 379                                 Char[] c1 = new Char[1];
 380                                 string[] s1 = new String[1];
 381                                 Array.Copy(c1, s1, 1);
 382                         } catch (ArrayTypeMismatchException) {
 383                                 errorThrown = true;
 384                         }
 385                         Assert.IsTrue (errorThrown, "#E04");
 386                 }
 387                 {
 388                         bool errorThrown = false;
 389                         try {
 390                                 Char[] c1 = new Char[1];
 391                                 Object[] o1 = new Object[1];
 392                                 o1[0] = "hello";
 393                                 Array.Copy(o1, c1, 1);
 394                         } catch (InvalidCastException) {
 395                                 errorThrown = true;
 396                         }
 397                         Assert.IsTrue (errorThrown, "#E05");
 398                 }
 399                 {
 400                         bool errorThrown = false;
 401                         try {
 402                                 Char[] c1 = new Char[1];
 403                                 Char[] c2 = new Char[1];
 404                                 Array.Copy(c1, c2, -1);
 405                         } catch (ArgumentOutOfRangeException) {
 406                                 errorThrown = true;
 407                         }
 408                         Assert.IsTrue (errorThrown, "#E06");
 409                 }
 410                 {
 411                         bool errorThrown = false;
 412                         try {
 413                                 Char[] c1 = new Char[1];
 414                                 Char[] c2 = new Char[2];
 415                                 Array.Copy(c1, c2, 2);
 416                         } catch (ArgumentException) {
 417                                 errorThrown = true;
 418                         }
 419                         Assert.IsTrue (errorThrown, "#E07");
 420                 }
 421                 {
 422                         bool errorThrown = false;
 423                         try {
 424                                 Char[] c1 = new Char[1];
 425                                 Char[] c2 = new Char[2];
 426                                 Array.Copy(c2, c1, 2);
 427                         } catch (ArgumentException) {
 428                                 errorThrown = true;
 429                         }
 430                         Assert.IsTrue (errorThrown, "#E08");
 431                 }
 432
 433                 char[] orig = {'a', 'b', 'd', 'a'};
 434                 char[] copy = new Char[4];
 435                 Array.Copy(orig, copy, 4);
 436                 for (int i = 0; i < orig.Length; i++) {
 437                         Assert.AreEqual (orig[i], copy[i], "#E09(" + i + ")");
 438                 }
 439                 Array.Clear(copy, 0, copy.Length);
 440                 for (int i = 0; i < orig.Length; i++) {
 441                         Assert.AreEqual ((char)0, copy[i], "#E10(" + i + ")");
 442                 }
 443                 Array.Copy(orig, copy, 2);
 444                 Assert.AreEqual (orig[0], copy[0], "#E11");
 445                 Assert.AreEqual (orig[1], copy[1], "#E12");
 446                 Assert.IsTrue (orig[2] != copy[2], "#E13");
 447                 Assert.IsTrue (orig[3] != copy[3], "#E14");
 448         }
 449
 450         [Test]
 451         public void TestCopy2() {
 452                 {
 453                         bool errorThrown = false;
 454                         try {
 455                                 Char[] c1 = new Char[2];
 456                                 Char[] c2 = new Char[2];
 457                                 Array.Copy(c2, 1, c1, 0, 2);
 458                         } catch (ArgumentException) {
 459                                 errorThrown = true;
 460                         }
 461                         Assert.IsTrue (errorThrown, "#E31");
 462                 }
 463                 {
 464                         bool errorThrown = false;
 465                         try {
 466                                 Char[] c1 = new Char[2];
 467                                 Char[] c2 = new Char[2];
 468                                 Array.Copy(c2, 0, c1, 1, 2);
 469                         } catch (ArgumentException) {
 470                                 errorThrown = true;
 471                         }
 472                         Assert.IsTrue (errorThrown, "#E32");
 473                 }
 474
 475                 char[] orig = {'a', 'b', 'd', 'a'};
 476                 char[] copy = new Char[4];
 477                 Array.Copy(orig, 1, copy, 1, 3);
 478                 Assert.IsTrue (copy[0] != orig[0], "#E33");
 479                 for (int i = 1; i < orig.Length; i++) {
 480                         Assert.AreEqual (orig[i], copy[i], "#E34(" + i + ")");
 481                 }
 482                 Array.Clear(copy, 0, copy.Length);
 483                 Array.Copy(orig, 1, copy, 0, 2);
 484                 Assert.AreEqual (orig[1], copy[0], "#E35");
 485                 Assert.AreEqual (orig[2], copy[1], "#E36");
 486                 Assert.IsTrue (copy[2] != orig[2], "#E37");
 487                 Assert.IsTrue (copy[3] != orig[3], "#E38");
 488         }
 489
 490         [Test]
 491         [ExpectedException (typeof (InvalidCastException))]
 492         public void Copy_InvalidCast () {
 493                 object[] arr1 = new object [10];
 494                 Type[] arr2 = new Type [10];
 495
 496                 arr1 [0] = new object ();
 497
 498                 Array.Copy (arr1, 0, arr2, 0, 10);
 499         }
 500
 501         [Test]
 502         public void TestCopyTo() {
 503                 {
 504                         bool errorThrown = false;
 505                         try {
 506                                 Char[] c1 = new Char[2];
 507                                 c1.CopyTo(null, 2);
 508                         } catch (ArgumentNullException) {
 509                                 errorThrown = true;
 510                         }
 511                         Assert.IsTrue (errorThrown, "#E61");
 512                 }
 513                 {
 514                         bool errorThrown = false;
 515                         try {
 516                                 Char[] c1 = new Char[2];
 517                                 Char[,] c2 = new Char[2,2];
 518                                 c1.CopyTo(c2, 2);
 519                         } catch (ArgumentException) {
 520                                 errorThrown = true;
 521                         }
 522 #if TARGET_JVM // This is really implementation dependent behaviour.
 523                         catch (RankException) {
 524                                 errorThrown = true;
 525                         }
 526 #endif // TARGET_JVM
 527                         Assert.IsTrue (errorThrown, "#E62");
 528                 }
 529                 {
 530                         bool errorThrown = false;
 531                         try {
 532                                 Char[,] c1 = new Char[2,2];
 533                                 Char[] c2 = new Char[2];
 534                                 c1.CopyTo(c2, -1);
 535                         } catch (RankException) {
 536                                 errorThrown = true;
 537                         }
 538                         Assert.IsTrue (errorThrown, "#E63");
 539                 }
 540                 {
 541                         bool errorThrown = false;
 542                         try {
 543                                 Char[,] c1 = new Char[2,2];
 544                                 Char[] c2 = new Char[2];
 545                                 c1.CopyTo(c2, 2);
 546                         } catch (RankException) {
 547                                 errorThrown = true;
 548                         }
 549                         Assert.IsTrue (errorThrown, "#E64");
 550                 }
 551                 {
 552                         bool errorThrown = false;
 553                         try {
 554                                 Char[] c1 = new Char[2];
 555                                 Char[] c2 = new Char[2];
 556                                 c1.CopyTo(c2, -1);
 557                         } catch (ArgumentOutOfRangeException) {
 558                                 errorThrown = true;
 559                         }
 560                         Assert.IsTrue (errorThrown, "#E65");
 561                 }
 562                 {
 563                         bool errorThrown = false;
 564                         try {
 565                                 Char[] c1 = new Char[2];
 566                                 Char[] c2 = new Char[2];
 567                                 c1.CopyTo(c2, 3);
 568                         } catch (ArgumentException) {
 569                                 errorThrown = true;
 570                         }
 571                         Assert.IsTrue (errorThrown, "#E66");
 572                 }
 573                 {
 574                         bool errorThrown = false;
 575                         try {
 576                                 Char[] c1 = new Char[2];
 577                                 Char[] c2 = new Char[2];
 578                                 c1.CopyTo(c2, 1);
 579                         } catch (ArgumentException) {
 580                                 errorThrown = true;
 581                         }
 582                         Assert.IsTrue (errorThrown, "#E67");
 583                 }
 584
 585                 {
 586                         bool errorThrown = false;
 587                         try {
 588                                 String[] c1 = new String[2];
 589                                 // TODO: this crashes mono if there are null
 590                                 // values in the array.
 591                                 c1[1] = "hey";
 592                                 c1[0] = "you";
 593                                 Char[] c2 = new Char[2];
 594                                 c2[1] = 'a';
 595                                 c2[0] = 'z';
 596                                 c1.CopyTo(c2, 0);
 597                         } catch (ArrayTypeMismatchException) {
 598                                 errorThrown = true;
 599                         }
 600                         Assert.IsTrue (errorThrown, "#E68");
 601                 }
 602
 603                 Char[] orig = {'a', 'b', 'c', 'd'};
 604                 Char[] copy = new Char[10];
 605                 Array.Clear(copy, 0, copy.Length);
 606                 orig.CopyTo(copy, 3);
 607                 Assert.AreEqual ((char)0, copy[0], "#E69");
 608                 Assert.AreEqual ((char)0, copy[1], "#E70");
 609                 Assert.AreEqual ((char)0, copy[2], "#E71");
 610                 Assert.AreEqual (orig[0], copy[3], "#E72");
 611                 Assert.AreEqual (orig[1], copy[4], "#E73");
 612                 Assert.AreEqual (orig[2], copy[5], "#E74");
 613                 Assert.AreEqual (orig[3], copy[6], "#E75");
 614                 Assert.AreEqual ((char)0, copy[7], "#E76");
 615                 Assert.AreEqual ((char)0, copy[8], "#E77");
 616                 Assert.AreEqual ((char)0, copy[9], "#E78");
 617
 618                 {
 619                         // The following is valid and must not throw an exception.
 620                         bool errorThrown = false;
 621                         try {
 622                                 int[] src = new int [0];
 623                                 int[] dest = new int [0];
 624                                 src.CopyTo (dest, 0);
 625                         } catch (ArgumentException) {
 626                                 errorThrown = true;
 627                         }
 628                         Assert.IsTrue (!errorThrown, "#E79");
 629                 }
 630
 631                 {
 632                         // bug #38812
 633                         bool errorThrown = false;
 634                         try {
 635                                 CClass[] src = new CClass [] { new CClass () };
 636                                 BClass[] dest = new BClass [1];
 637
 638                                 src.CopyTo (dest, 0);
 639
 640                         } catch (ArrayTypeMismatchException) {
 641                                 errorThrown = true;
 642                         }
 643                         Assert.IsTrue (errorThrown, "#E80");
 644                 }
 645         }
 646
 647         [Test]
 648         public void TestCreateInstance() {
 649                 {
 650                         bool errorThrown = false;
 651                         try {
 652                                 Array.CreateInstance(null, 12);
 653                         } catch (ArgumentNullException) {
 654                                 errorThrown = true;
 655                         }
 656                         Assert.IsTrue (errorThrown, "#F01");
 657                 }
 658                 {
 659                         bool errorThrown = false;
 660                         try {
 661                                 Array.CreateInstance(Type.GetType("System.Char"), -3);
 662                         } catch (ArgumentOutOfRangeException) {
 663                                 errorThrown = true;
 664                         }
 665                         Assert.IsTrue (errorThrown, "#F02");
 666                 }
 667                 {
 668                         bool errorThrown = false;
 669                         try {
 670                                 Array.CreateInstance(Type.GetType("System.Char"), (int [])null);
 671                         } catch (ArgumentNullException) {
 672                                 errorThrown = true;
 673                         }
 674                         Assert.IsTrue (errorThrown, "#F03a");
 675                 }
 676
 677                 {
 678                         bool errorThrown = false;
 679                         try {
 680                                 Array.CreateInstance(Type.GetType("System.Char"), (int [])null);
 681                         } catch (ArgumentNullException) {
 682                                 errorThrown = true;
 683                         }
 684                         Assert.IsTrue (errorThrown, "#F03b");
 685                 }
 686 #if !TARGET_JVM // Arrays lower bounds are not supported for TARGET_JVM
 687                 {
 688                         bool errorThrown = false;
 689                         try {
 690                                 Array.CreateInstance(Type.GetType("System.Char"), null, null);
 691                         } catch (ArgumentNullException) {
 692                                 errorThrown = true;
 693                         }
 694                         Assert.IsTrue (errorThrown, "#F04");
 695                 }
 696 #endif // TARGET_JVM
 697                 {
 698                         bool errorThrown = false;
 699                         try {
 700                                 int[] lengths = new int [0];
 701                                 Array.CreateInstance(Type.GetType("System.Char"), lengths);
 702                         } catch (ArgumentException) {
 703                                 errorThrown = true;
 704                         }
 705                         Assert.IsTrue (errorThrown, "#F05");
 706                 }
 707 #if !TARGET_JVM // CreateInstance with lower bounds not supported for TARGET_JVM
 708                 {
 709                         bool errorThrown = false;
 710                         try {
 711                                 int[] lengths = new int [1];
 712                                 int[] bounds = new int [2];
 713                                 Array.CreateInstance(Type.GetType("System.Char"), lengths, bounds);
 714                                 errorThrown = true;
 715                         } catch (ArgumentException) {
 716                                 errorThrown = true;
 717                         }
 718                         Assert.IsTrue (errorThrown, "#F06");
 719                 }
 720
 721                 char[] c1 = (char[])Array.CreateInstance(Type.GetType("System.Char"), 12);
 722                 Assert.AreEqual (12, c1.Length, "#F07");
 723
 724                 Array c2 = Array.CreateInstance(Type.GetType("System.Char"), 12, 5);
 725                 Assert.AreEqual (2, c2.Rank, "#F08");
 726                 Assert.AreEqual (60, c2.Length, "#F09");
 727
 728
 729                 {
 730                         int[] lengths = { 3 };
 731                         int[] bounds = { 5 };
 732                         int[] src = { 512, 718, 912 };
 733                         Array array = Array.CreateInstance(typeof(int), lengths, bounds);
 734
 735                         Assert.AreEqual (3, array.Length, "#F10");
 736                         Assert.AreEqual (5, array.GetLowerBound(0), "#F11");
 737                         Assert.AreEqual (7, array.GetUpperBound(0), "#F12");
 738
 739                         src.CopyTo (array, 5);
 740
 741                         for (int i = 0; i < src.Length; i++)
 742                                 Assert.AreEqual (src[i], array.GetValue(i+5), "#F13(" + i + ")");
 743                 }
 744
 745                 // Test that a 1 dimensional array with 0 lower bound is the
 746                 // same as an szarray
 747                 Type szarrayType = new int [10].GetType ();
 748                 Assert.IsTrue (szarrayType == (Array.CreateInstance (typeof (int), new int[] {1}, new int[] {0})).GetType ());
 749                 Assert.IsTrue (szarrayType != (Array.CreateInstance (typeof (int), new int[] {1}, new int[] {1})).GetType ());
 750 #endif // TARGET_JVM
 751         }
 752
 753         [Test]
 754         [ExpectedException (typeof (ArgumentNullException))]
 755         public void TestCreateInstance2 ()
 756         {
 757                 Array.CreateInstance (typeof (Int32), (int[])null);
 758         }
 759
 760         [Test]
 761         [ExpectedException (typeof (ArgumentNullException))]
 762         public void TestCreateInstance2b ()
 763         {
 764                 Array.CreateInstance (typeof (Int32), (long[])null);
 765         }
 766
 767         [Test]
 768         public void TestGetEnumerator() {
 769                 String[] s1 = {"this", "is", "a", "test"};
 770                 IEnumerator en = s1.GetEnumerator ();
 771                 Assert.IsNotNull (en, "#G01");
 772
 773                 Assert.IsTrue (en.MoveNext (), "#G02");
 774                 Assert.AreEqual ("this", en.Current, "#G03");
 775                 Assert.IsTrue (en.MoveNext (), "#G04");
 776                 Assert.AreEqual ("is", en.Current, "#G05");
 777                 Assert.IsTrue (en.MoveNext (), "#G06");
 778                 Assert.AreEqual ("a", en.Current, "#G07");
 779                 Assert.IsTrue (en.MoveNext (), "#G08");
 780                 Assert.AreEqual ("test", en.Current, "#G09");
 781                 Assert.IsTrue (!en.MoveNext (), "#G10");
 782
 783                 en.Reset ();
 784                 Assert.IsTrue (en.MoveNext (), "#G11");
 785                 Assert.AreEqual ("this", en.Current, "#G12");
 786
 787                 // mutation does not invalidate array enumerator!
 788                 s1.SetValue ("change", 1);
 789                 Assert.IsTrue (en.MoveNext (), "#G13");
 790                 Assert.AreEqual ("change", en.Current, "#G14");
 791         }
 792
 793         [Test]
 794         public void TestGetEnumeratorMultipleDimension() {
 795                 String[,] s1 = {{"this", "is"}, {"a", "test"}};
 796                 IEnumerator en = s1.GetEnumerator ();
 797                 Assert.IsNotNull (en, "#AA01");
 798
 799                 Assert.IsTrue (en.MoveNext (), "#AA02");
 800                 Assert.AreEqual ("this", en.Current, "#AA03");
 801                 Assert.IsTrue (en.MoveNext (), "#AA04");
 802                 Assert.AreEqual ("is", en.Current, "#AA05");
 803                 Assert.IsTrue (en.MoveNext (), "#AA06");
 804                 Assert.AreEqual ("a", en.Current, "#AA07");
 805                 Assert.IsTrue (en.MoveNext (), "#AA08");
 806                 Assert.AreEqual ("test", en.Current, "#AA09");
 807                 Assert.IsTrue (!en.MoveNext (), "#AA10");
 808
 809                 en.Reset ();
 810                 Assert.IsTrue (en.MoveNext (), "#AA11");
 811                 Assert.AreEqual ("this", en.Current, "#AA12");
 812
 813                 int[] idxs = {0,1};
 814                 // mutation does not invalidate array enumerator!
 815                 s1.SetValue ("change", idxs);
 816                 Assert.IsTrue (en.MoveNext (), "#AA13");
 817                 Assert.AreEqual ("change", en.Current, "#AA14");
 818         }
 819
 820         [Test]
 821         [Category ("TargetJvmNotSupported")] // Arrays lower bounds are not supported for TARGET_JVM
 822         public void TestGetEnumeratorNonZeroLowerBounds() {
 823                 int[] myLengthsArray = new int[2] { 3, 5 };
 824                 int[] myBoundsArray = new int[2] { 2, 3 };
 825
 826                 Array myArray=Array.CreateInstance( typeof(String), myLengthsArray, myBoundsArray );
 827                 for ( int i = myArray.GetLowerBound(0); i <= myArray.GetUpperBound(0); i++ )
 828                         for ( int j = myArray.GetLowerBound(1); j <= myArray.GetUpperBound(1); j++ )  {
 829                                 int[] myIndicesArray = new int[2] { i, j };
 830                                 myArray.SetValue( Convert.ToString(i) + j, myIndicesArray );
 831                         }
 832                 IEnumerator en = myArray.GetEnumerator ();
 833                 Assert.IsNotNull (en, "#AB01");
 834
 835                 // check the first couple of values
 836                 Assert.IsTrue (en.MoveNext (), "#AB02");
 837                 Assert.AreEqual ("23", en.Current, "#AB03");
 838                 Assert.IsTrue (en.MoveNext (), "#AB04");
 839                 Assert.AreEqual ("24", en.Current, "#AB05");
 840
 841                 // then check the last element's value
 842                 string lastElement;
 843                 do {
 844                         lastElement = (string)en.Current;
 845                 } while (en.MoveNext());
 846                 Assert.AreEqual ("47", lastElement, "#AB06");
 847         }
 848
 849         [Test]
 850         [Category ("TargetJvmNotSupported")] // Arrays lower bounds are not supported for TARGET_JVM
 851         public void TestIList_Add () {
 852                 int[] myLengthsArray = new int[2] { 3, 5 };
 853                 int[] myBoundsArray = new int[2] { 2, 3 };
 854
 855                 Array myArray=Array.CreateInstance ( typeof(String), myLengthsArray, myBoundsArray );
 856                 try {
 857                         ((IList)myArray).Add ("can not");
 858                         Assert.Fail ("IList.Add should throw");
 859                 }
 860                 catch (NotSupportedException) {
 861                         return;
 862                 }
 863                 catch (Exception) {
 864                         Assert.Fail ("IList.Add threw wrong exception type");
 865                 }
 866
 867                 Assert.Fail ("IList.Add shouldn't get this far");
 868         }
 869
 870         [Test]
 871         [Category ("TargetJvmNotSupported")] // Arrays lower bounds are not supported for TARGET_JVM
 872         public void TestIList_Insert () {
 873                 int[] myLengthsArray = new int[2] { 3, 5 };
 874                 int[] myBoundsArray = new int[2] { 2, 3 };
 875
 876                 Array myArray=Array.CreateInstance ( typeof(String), myLengthsArray, myBoundsArray );
 877                 try {
 878                         ((IList)myArray).Insert (0, "can not");
 879                         Assert.Fail ("IList.Insert should throw");
 880                 }
 881                 catch (NotSupportedException) {
 882                         return;
 883                 }
 884                 catch (Exception) {
 885                         Assert.Fail ("IList.Insert threw wrong exception type");
 886                 }
 887
 888                 Assert.Fail ("IList.Insert shouldn't get this far");
 889         }
 890
 891         [Test]
 892         [Category ("TargetJvmNotSupported")] // Arrays lower bounds are not supported for TARGET_JVM
 893         public void TestIList_Remove () {
 894                 int[] myLengthsArray = new int[2] { 3, 5 };
 895                 int[] myBoundsArray = new int[2] { 2, 3 };
 896
 897                 Array myArray=Array.CreateInstance ( typeof(String), myLengthsArray, myBoundsArray );
 898                 try {
 899                         ((IList)myArray).Remove ("can not");
 900                         Assert.Fail ("IList.Remove should throw");
 901                 }
 902                 catch (NotSupportedException) {
 903                         return;
 904                 }
 905                 catch (Exception) {
 906                         Assert.Fail ("IList.Remove threw wrong exception type");
 907                 }
 908
 909                 Assert.Fail ("IList.Remove shouldn't get this far");
 910         }
 911
 912         [Test]
 913         [Category ("TargetJvmNotSupported")] // Arrays lower bounds are not supported for TARGET_JVM
 914         public void TestIList_RemoveAt () {
 915                 int[] myLengthsArray = new int[2] { 3, 5 };
 916                 int[] myBoundsArray = new int[2] { 2, 3 };
 917
 918                 Array myArray=Array.CreateInstance ( typeof(String), myLengthsArray, myBoundsArray );
 919                 try {
 920                         ((IList)myArray).RemoveAt (0);
 921                         Assert.Fail ("IList.RemoveAt should throw");
 922                 }
 923                 catch (NotSupportedException) {
 924                         return;
 925                 }
 926                 catch (Exception) {
 927                         Assert.Fail ("IList.RemoveAt threw wrong exception type");
 928                 }
 929
 930                 Assert.Fail ("IList.RemoveAt shouldn't get this far");
 931         }
 932
 933         [Test]
 934         [Category ("TargetJvmNotSupported")] // Arrays lower bounds are not supported for TARGET_JVM
 935         public void TestIList_Contains () {
 936                 int[] myLengthsArray = new int[2] { 3, 5 };
 937                 int[] myBoundsArray = new int[2] { 2, 3 };
 938
 939                 Array myArray=Array.CreateInstance ( typeof(String), myLengthsArray, myBoundsArray );
 940
 941                 try {
 942                         bool b = ((IList)myArray).Contains ("23");
 943                         Assert.Fail ("IList.Contains should throw with multi-dimensional arrays");
 944                 }
 945                 catch (RankException) {
 946                         int[] iArr = new int[3] { 1, 2, 3};
 947                         // check the first and last items
 948                         Assert.IsTrue (((IList)iArr).Contains (1), "AC01");
 949                         Assert.IsTrue (((IList)iArr).Contains (3), "AC02");
 950
 951                         // and one that is definately not there
 952                         Assert.IsTrue (!((IList)iArr).Contains (42), "AC03");
 953                         return;
 954                 }
 955
 956                 Assert.Fail ("Should not get here");
 957         }
 958
 959         [Test]
 960         [Category ("TargetJvmNotSupported")] // Arrays lower bounds are not supported for TARGET_JVM
 961         public void TestIList_IndexOf () {
 962                 int[] myLengthsArray = new int[2] { 3, 5 };
 963                 int[] myBoundsArray = new int[2] { 2, 3 };
 964
 965                 Array myArray=Array.CreateInstance ( typeof(String), myLengthsArray, myBoundsArray );
 966
 967                 try {
 968                         bool b = ((IList)myArray).Contains ("23");
 969                         Assert.Fail ("IList.Contains should throw with multi-dimensional arrays");
 970                 }
 971                 catch (RankException) {
 972                         int[] iArr = new int[3] { 1, 2, 3};
 973                         // check the first and last items
 974                         Assert.AreEqual (0, ((IList)iArr).IndexOf (1), "AD01");
 975                         Assert.AreEqual (2, ((IList)iArr).IndexOf (3), "AD02");
 976
 977                         // and one that is definately not there
 978                         Assert.AreEqual (-1, ((IList)iArr).IndexOf (42), "AD03");
 979                 }
 980                 catch (Exception e) {
 981                         Assert.Fail ("Unexpected exception: " + e.ToString());
 982                 }
 983
 984                 // check that wierd case whem lowerbound is Int32.MinValue,
 985                 // so that IndexOf() needs to return Int32.MaxValue when it cannot find the object
 986                 int[] myLengthArray = new int[1] { 3 };
 987                 int[] myBoundArray = new int[1] { Int32.MinValue };
 988                 Array myExtremeArray=Array.CreateInstance ( typeof(String), myLengthArray, myBoundArray );
 989                 Assert.AreEqual (Int32.MaxValue, ((IList)myExtremeArray).IndexOf (42), "AD04");
 990
 991         }
 992
 993         [Test]
 994         public void TestGetLength() {
 995                 {
 996                         bool errorThrown = false;
 997                         try {
 998                                 char[] c1 = {'a', 'b', 'c'};
 999                                 c1.GetLength(-1);
1000                         } catch (IndexOutOfRangeException) {
1001                                 errorThrown = true;
1002                         }
1003                         Assert.IsTrue (errorThrown, "#H01");
1004                 }
1005                 {
1006                         bool errorThrown = false;
1007                         try {
1008                                 char[] c1 = {'a', 'b', 'c'};
1009                                 c1.GetLength(1);
1010                         } catch (IndexOutOfRangeException) {
1011                                 errorThrown = true;
1012                         }
1013                         Assert.IsTrue (errorThrown, "#H02");
1014                 }
1015
1016                 char[] c2 = new Char[5];
1017                 Assert.AreEqual (5, c2.GetLength(0), "#H03");
1018
1019                 char[,] c3 = new Char[6,7];
1020                 Assert.AreEqual (6, c3.GetLength(0), "#H04");
1021                 Assert.AreEqual (7, c3.GetLength(1), "#H05");
1022         }
1023
1024         [Test]
1025         public void TestGetLowerBound() {
1026                 {
1027                         bool errorThrown = false;
1028                         try {
1029                                 char[] c = {'a', 'b', 'c'};
1030                                 c.GetLowerBound(-1);
1031                         } catch (IndexOutOfRangeException) {
1032                                 errorThrown = true;
1033                         }
1034                         Assert.IsTrue (errorThrown, "#H31");
1035                 }
1036                 {
1037                         bool errorThrown = false;
1038                         try {
1039                                 char[] c = {'a', 'b', 'c'};
1040                                 c.GetLowerBound(1);
1041                         } catch (IndexOutOfRangeException) {
1042                                 errorThrown = true;
1043                         }
1044                         Assert.IsTrue (errorThrown, "#H32");
1045                 }
1046
1047                 char[] c1 = new Char[5];
1048                 Assert.AreEqual (0, c1.GetLowerBound(0), "#H33");
1049
1050                 char[,] c2 = new Char[4,4];
1051                 Assert.AreEqual (0, c2.GetLowerBound(0), "#H34");
1052                 Assert.AreEqual (0, c2.GetLowerBound(1), "#H35");
1053         }
1054
1055         [Test]
1056         public void TestGetUpperBound() {
1057                 {
1058                         bool errorThrown = false;
1059                         try {
1060                                 char[] c = {'a', 'b', 'c'};
1061                                 c.GetUpperBound(-1);
1062                         } catch (IndexOutOfRangeException) {
1063                                 errorThrown = true;
1064                         }
1065                         Assert.IsTrue (errorThrown, "#H61");
1066                 }
1067                 {
1068                         bool errorThrown = false;
1069                         try {
1070                                 char[] c = {'a', 'b', 'c'};
1071                                 c.GetUpperBound(1);
1072                         } catch (IndexOutOfRangeException) {
1073                                 errorThrown = true;
1074                         }
1075                         Assert.IsTrue (errorThrown, "#H62");
1076                 }
1077
1078                 char[] c1 = new Char[5];
1079                 Assert.AreEqual (4, c1.GetUpperBound(0), "#H63");
1080
1081                 char[,] c2 = new Char[4,6];
1082                 Assert.AreEqual (3, c2.GetUpperBound(0), "#H64");
1083                 Assert.AreEqual (5, c2.GetUpperBound(1), "#H65");
1084         }
1085
1086         [Test]
1087         public void TestGetValue1() {
1088                 {
1089                         bool errorThrown = false;
1090                         try {
1091                                 char[,] c = new Char[2,2];
1092                                 c.GetValue(1);
1093                         } catch (ArgumentException) {
1094                                 errorThrown = true;
1095                         }
1096                         Assert.IsTrue (errorThrown, "#I01");
1097                 }
1098                 {
1099                         bool errorThrown = false;
1100                         try {
1101                                 char[] c = {'a', 'b', 'c'};
1102                                 c.GetValue(-1);
1103                         } catch (IndexOutOfRangeException) {
1104                                 errorThrown = true;
1105                         }
1106                         Assert.IsTrue (errorThrown, "#I02");
1107                 }
1108                 {
1109                         bool errorThrown = false;
1110                         try {
1111                                 char[] c = {'a', 'b', 'c'};
1112                                 c.GetValue(4);
1113                         } catch (IndexOutOfRangeException) {
1114                                 errorThrown = true;
1115                         }
1116                         Assert.IsTrue (errorThrown, "#I03");
1117                 }
1118
1119                 char[] c1 = {'a', 'b', 'c', 'd'};
1120                 for (int i = 0; i < c1.Length; i++) {
1121                         Assert.AreEqual (c1[i], c1.GetValue(i), "#I04(" + i + ")");
1122                 }
1123         }
1124
1125         [Test]
1126         public void TestGetValue2() {
1127                 {
1128                         bool errorThrown = false;
1129                         try {
1130                                 char[] c = new Char[2];
1131                                 c.GetValue(1,1);
1132                         } catch (ArgumentException) {
1133                                 errorThrown = true;
1134                         }
1135                         Assert.IsTrue (errorThrown, "#I21");
1136                 }
1137                 {
1138                         bool errorThrown = false;
1139                         try {
1140                                 char[,] c = new Char[2,2];
1141                                 c.GetValue(-1, 1);
1142                         } catch (IndexOutOfRangeException) {
1143                                 errorThrown = true;
1144                         }
1145                         Assert.IsTrue (errorThrown, "#I22");
1146                 }
1147                 {
1148                         bool errorThrown = false;
1149                         try {
1150                                 char[,] c = new Char[2,2];
1151                                 c.GetValue(4,1);
1152                         } catch (IndexOutOfRangeException) {
1153                                 errorThrown = true;
1154                         }
1155                         Assert.IsTrue (errorThrown, "#I23");
1156                 }
1157
1158                 char[,] c1 = new Char[4,6];
1159                 for (int i = 0; i < 24; i++) {
1160                         int first = i / 6;
1161                         int second = i % 6;
1162                         c1[first,second] = (char)(((int)'a')+i);
1163                 }
1164                 for (int i = 0; i < c1.GetLength(0); i++) {
1165                         for (int j = 0; j < c1.GetLength(1); j++) {
1166                                 Assert.AreEqual (c1[i, j], c1.GetValue(i, j), "#I24(" + i + "," + j + ")");
1167                         }
1168                 }
1169         }
1170
1171         [Test]
1172         public void TestGetValue3() {
1173                 {
1174                         bool errorThrown = false;
1175                         try {
1176                                 char[] c = new Char[2];
1177                                 c.GetValue(1,1,1);
1178                         } catch (ArgumentException) {
1179                                 errorThrown = true;
1180                         }
1181                         Assert.IsTrue (errorThrown, "#I41");
1182                 }
1183                 {
1184                         bool errorThrown = false;
1185                         try {
1186                                 char[,,] c = new Char[2,2,2];
1187                                 c.GetValue(-1, 1, 1);
1188                         } catch (IndexOutOfRangeException) {
1189                                 errorThrown = true;
1190                         }
1191                         Assert.IsTrue (errorThrown, "#I42");
1192                 }
1193                 {
1194                         bool errorThrown = false;
1195                         try {
1196                                 char[,,] c = new Char[2,2,2];
1197                                 c.GetValue(4,1,1);
1198                         } catch (IndexOutOfRangeException) {
1199                                 errorThrown = true;
1200                         }
1201                         Assert.IsTrue (errorThrown, "#I43");
1202                 }
1203
1204                 char[,,] c1 = new Char[4,2,3];
1205                 for (int i = 0; i < 24; i++) {
1206                         int first = i / 6;
1207                         int remains = i % 6;
1208                         int second = remains / 3;
1209                         int third = remains % 3;
1210                         c1[first,second, third] = (char)(((int)'a')+i);
1211                 }
1212                 for (int i = 0; i < c1.GetLength(0); i++) {
1213                         for (int j = 0; j < c1.GetLength(1); j++) {
1214                                 for (int k = 0; k < c1.GetLength(2); k++) {
1215                                         Assert.AreEqual (c1[i, j, k], c1.GetValue(i, j, k), "#I44(" + i + "," + j + ")");
1216                                 }
1217                         }
1218                 }
1219         }
1220
1221         [Test]
1222         [ExpectedException (typeof (ArgumentNullException))]
1223         public void TestGetValueLongArray ()
1224         {
1225                 char[] c = new Char[2];
1226                 c.GetValue((long [])null);
1227         }
1228
1229         [Test]
1230         public void TestGetValueN() {
1231                 {
1232                         bool errorThrown = false;
1233                         try {
1234                                 char[] c = new Char[2];
1235                                 c.GetValue((int [])null);
1236                         } catch (ArgumentNullException) {
1237                                 errorThrown = true;
1238                         }
1239                         Assert.IsTrue (errorThrown, "#I61a");
1240                 }
1241                 {
1242                         bool errorThrown = false;
1243                         try {
1244                                 char[] c = new Char[2];
1245                                 int[] coords = {1, 1};
1246                                 c.GetValue(coords);
1247                         } catch (ArgumentException) {
1248                                 errorThrown = true;
1249                         }
1250                         Assert.IsTrue (errorThrown, "#I62");
1251                 }
1252                 {
1253                         bool errorThrown = false;
1254                         try {
1255                                 char[,] c = new Char[2,2];
1256                                 int[] coords = {-1, 1};
1257                                 c.GetValue(coords);
1258                         } catch (IndexOutOfRangeException) {
1259                                 errorThrown = true;
1260                         }
1261                         Assert.IsTrue (errorThrown, "#I63");
1262                 }
1263                 {
1264                         bool errorThrown = false;
1265                         try {
1266                                 char[,] c = new Char[2,2];
1267                                 int[] coords = {4, 1};
1268                                 c.GetValue(coords);
1269                         } catch (IndexOutOfRangeException) {
1270                                 errorThrown = true;
1271                         }
1272                         Assert.IsTrue (errorThrown, "#I64");
1273                 }
1274
1275                 char[,] c1 = new Char[4,6];
1276                 for (int i = 0; i < 24; i++) {
1277                         int first = i / 6;
1278                         int second = i % 6;
1279                         c1[first,second] = (char)(((int)'a')+i);
1280                 }
1281                 for (int i = 0; i < c1.GetLength(0); i++) {
1282                         for (int j = 0; j < c1.GetLength(1); j++) {
1283                                 int[] coords = {i, j};
1284                                 Assert.AreEqual (c1[i, j], c1.GetValue(coords), "#I65(" + i + "," + j + ")");
1285                         }
1286                 }
1287         }
1288
1289         [Test]
1290         public void TestIndexOf1() {
1291                 {
1292                         bool errorThrown = false;
1293                         try {
1294                                 Array.IndexOf(null, "huh?");
1295                         } catch (ArgumentNullException) {
1296                                 errorThrown = true;
1297                         }
1298                         Assert.IsTrue (errorThrown, "#J01");
1299                 }
1300                 {
1301                         bool errorThrown = false;
1302                         try {
1303                                 char[,] c = new Char[2,2];
1304                                 Array.IndexOf(c, "huh?");
1305                         } catch (RankException) {
1306                                 errorThrown = true;
1307                         }
1308                         Assert.IsTrue (errorThrown, "#J02");
1309                 }
1310
1311                 String[] s1 = {"this", "is", "a", "test"};
1312                 Assert.AreEqual (-1, Array.IndexOf(s1, null), "#J03");
1313                 Assert.AreEqual (-1, Array.IndexOf(s1, "nothing"), "#J04");
1314                 Assert.AreEqual (0, Array.IndexOf(s1, "this"), "#J05");
1315                 Assert.AreEqual (3, Array.IndexOf(s1, "test"), "#J06");
1316         }
1317
1318         [Test]
1319         public void TestIndexOf2() {
1320                 {
1321                         bool errorThrown = false;
1322                         try {
1323                                 Array.IndexOf(null, "huh?", 0);
1324                         } catch (ArgumentNullException) {
1325                                 errorThrown = true;
1326                         }
1327                         Assert.IsTrue (errorThrown, "#J21");
1328                 }
1329                 {
1330                         bool errorThrown = false;
1331                         try {
1332                                 char[,] c = new Char[2,2];
1333                                 Array.IndexOf(c, "huh?", 0);
1334                         } catch (RankException) {
1335                                 errorThrown = true;
1336                         }
1337                         Assert.IsTrue (errorThrown, "#J22");
1338                 }
1339                 {
1340                         bool errorThrown = false;
1341                         try {
1342                                 char[] c = new Char[2];
1343                                 Array.IndexOf(c, "huh?", 3);
1344                         } catch (ArgumentOutOfRangeException) {
1345                                 errorThrown = true;
1346                         }
1347                         Assert.IsTrue (errorThrown, "#J23");
1348                 }
1349
1350                 String[] s1 = {"this", "is", "really", "a", "test"};
1351                 Assert.AreEqual (-1, Array.IndexOf(s1, null, 1), "#J24");
1352                 Assert.AreEqual (-1, Array.IndexOf(s1, "nothing", 1), "#J25");
1353                 Assert.AreEqual (-1, Array.IndexOf(s1, "this", 1), "#J26");
1354                 Assert.AreEqual (1, Array.IndexOf(s1, "is", 1), "#J27");
1355                 Assert.AreEqual (4, Array.IndexOf(s1, "test", 1), "#J28");
1356         }
1357
1358         [Test]
1359         public void TestIndexOf3() {
1360                 {
1361                         bool errorThrown = false;
1362                         try {
1363                                 Array.IndexOf(null, "huh?", 0, 1);
1364                         } catch (ArgumentNullException) {
1365                                 errorThrown = true;
1366                         }
1367                         Assert.IsTrue (errorThrown, "#J41");
1368                 }
1369                 {
1370                         bool errorThrown = false;
1371                         try {
1372                                 char[,] c = new Char[2,2];
1373                                 Array.IndexOf(c, "huh?", 0, 1);
1374                         } catch (RankException) {
1375                                 errorThrown = true;
1376                         }
1377                         Assert.IsTrue (errorThrown, "#J42");
1378                 }
1379                 {
1380                         bool errorThrown = false;
1381                         try {
1382                                 char[] c = new Char[2];
1383                                 Array.IndexOf(c, "huh?", 3, 1);
1384                         } catch (ArgumentOutOfRangeException) {
1385                                 errorThrown = true;
1386                         }
1387                         Assert.IsTrue (errorThrown, "#J43");
1388                 }
1389                 {
1390                         bool errorThrown = false;
1391                         try {
1392                                 char[] c = new Char[2];
1393                                 Array.IndexOf(c, "huh?", 0, 5);
1394                         } catch (ArgumentOutOfRangeException) {
1395                                 errorThrown = true;
1396                         }
1397                         Assert.IsTrue (errorThrown, "#J44");
1398                 }
1399
1400                 String[] s1 = {"this", "is", "really", "a", "test"};
1401                 Assert.AreEqual (-1, Array.IndexOf(s1, null, 1, 3), "#J45");
1402                 Assert.AreEqual (-1, Array.IndexOf(s1, "nothing", 1, 3), "#J46");
1403                 Assert.AreEqual (-1, Array.IndexOf(s1, "this", 1, 3), "#J47");
1404                 Assert.AreEqual (1, Array.IndexOf(s1, "is", 1, 3), "#J48");
1405                 Assert.AreEqual (-1, Array.IndexOf(s1, "test", 1, 3), "#J49");
1406                 Assert.AreEqual (3, Array.IndexOf(s1, "a", 1, 3), "#J50");
1407         }
1408
1409         [Test]
1410         public void TestIndexOf_CustomEqual ()
1411         {
1412                 DataEqual[] test = new DataEqual [] { new DataEqual () };
1413                 Assert.AreEqual (0, Array.IndexOf (test, "asdfas", 0));
1414
1415                 IList array = (IList)test;
1416                 Assert.AreEqual (0, array.IndexOf ("asdfas"));
1417         }
1418
1419         [Test]
1420         public void TestLastIndexOf1() {
1421                 {
1422                         bool errorThrown = false;
1423                         try {
1424                                 Array.LastIndexOf(null, "huh?");
1425                         } catch (ArgumentNullException) {
1426                                 errorThrown = true;
1427                         }
1428                         Assert.IsTrue (errorThrown, "#K01");
1429                 }
1430                 {
1431                         bool errorThrown = false;
1432                         try {
1433                                 char[,] c = new Char[2,2];
1434                                 Array.LastIndexOf(c, "huh?");
1435                         } catch (RankException) {
1436                                 errorThrown = true;
1437                         }
1438                         Assert.IsTrue (errorThrown, "#K02");
1439                 }
1440
1441                 String[] s1 = {"this", "is", "a", "a", "test"};
1442                 Assert.AreEqual (-1, Array.LastIndexOf(s1, null), "#K03");
1443                 Assert.AreEqual (-1, Array.LastIndexOf(s1, "nothing"), "#K04");
1444                 Assert.AreEqual (0, Array.LastIndexOf(s1, "this"), "#K05");
1445                 Assert.AreEqual (4, Array.LastIndexOf(s1, "test"), "#K06");
1446                 Assert.AreEqual (3, Array.LastIndexOf(s1, "a"), "#K07");
1447
1448                 Assert.AreEqual (-1, Array.LastIndexOf (new String [0], "foo"));
1449         }
1450
1451         [Test]
1452         public void TestLastIndexOf2() {
1453                 {
1454                         bool errorThrown = false;
1455                         try {
1456                                 Array.LastIndexOf(null, "huh?", 0);
1457                         } catch (ArgumentNullException) {
1458                                 errorThrown = true;
1459                         }
1460                         Assert.IsTrue (errorThrown, "#K21");
1461                 }
1462                 {
1463                         bool errorThrown = false;
1464                         try {
1465                                 char[,] c = new Char[2,2];
1466                                 Array.LastIndexOf(c, "huh?", 0);
1467                         } catch (RankException) {
1468                                 errorThrown = true;
1469                         }
1470                         Assert.IsTrue (errorThrown, "#K22");
1471                 }
1472                 {
1473                         bool errorThrown = false;
1474                         try {
1475                                 char[] c = new Char[2];
1476                                 Array.LastIndexOf(c, "huh?", 3);
1477                         } catch (ArgumentOutOfRangeException) {
1478                                 errorThrown = true;
1479                         }
1480                         Assert.IsTrue (errorThrown, "#K23");
1481                 }
1482
1483                 String[] s1 = {"this", "is", "really", "a", "test"};
1484                 Assert.AreEqual (-1, Array.LastIndexOf(s1, null, 3), "#K24");
1485                 Assert.AreEqual (-1, Array.LastIndexOf(s1, "nothing", 3), "#K25");
1486                 Assert.AreEqual (-1, Array.LastIndexOf(s1, "test", 3), "#K26");
1487                 Assert.AreEqual (3, Array.LastIndexOf(s1, "a", 3), "#K27");
1488                 Assert.AreEqual (0, Array.LastIndexOf(s1, "this", 3), "#K28");
1489         }
1490
1491         [Test]
1492         public void TestLastIndexOf3() {
1493                 {
1494                         bool errorThrown = false;
1495                         try {
1496                                 Array.LastIndexOf(null, "huh?", 0, 1);
1497                         } catch (ArgumentNullException) {
1498                                 errorThrown = true;
1499                         }
1500                         Assert.IsTrue (errorThrown, "#K41");
1501                 }
1502                 {
1503                         bool errorThrown = false;
1504                         try {
1505                                 char[,] c = new Char[2,2];
1506                                 Array.LastIndexOf(c, "huh?", 0, 1);
1507                         } catch (RankException) {
1508                                 errorThrown = true;
1509                         }
1510                         Assert.IsTrue (errorThrown, "#K42");
1511                 }
1512                 {
1513                         bool errorThrown = false;
1514                         try {
1515                                 char[] c = new Char[2];
1516                                 Array.LastIndexOf(c, "huh?", 3, 1);
1517                         } catch (ArgumentOutOfRangeException) {
1518                                 errorThrown = true;
1519                         }
1520                         Assert.IsTrue (errorThrown, "#K43");
1521                 }
1522                 {
1523                         bool errorThrown = false;
1524                         try {
1525                                 char[] c = new Char[2];
1526                                 Array.LastIndexOf(c, "huh?", 0, 5);
1527                         } catch (ArgumentOutOfRangeException) {
1528                                 errorThrown = true;
1529                         }
1530                         Assert.IsTrue (errorThrown, "#K44");
1531                 }
1532
1533                 String[] s1 = {"this", "is", "really", "a", "test"};
1534                 Assert.AreEqual (-1, Array.LastIndexOf(s1, null, 3, 3), "#K45");
1535                 Assert.AreEqual (-1, Array.LastIndexOf(s1, "nothing", 3, 3), "#K46");
1536                 Assert.AreEqual (-1, Array.LastIndexOf(s1, "this", 3, 3), "#K47");
1537                 Assert.AreEqual (1, Array.LastIndexOf(s1, "is", 3, 3), "#K48");
1538                 Assert.AreEqual (-1, Array.LastIndexOf(s1, "test", 3, 3), "#K49");
1539                 Assert.AreEqual (3, Array.LastIndexOf(s1, "a", 3, 3), "#K50");
1540         }
1541
1542         [Test]
1543         public void TestLastIndexOf4 ()
1544         {
1545                 short [] a = new short [] { 19, 238, 317, 6, 565, 0, -52, 60, -563, 753, 238, 238};
1546                 try {
1547                         Array.LastIndexOf (a, (object)16, -1);
1548                         NUnit.Framework.Assert.Fail ("#1");
1549                 } catch (ArgumentOutOfRangeException) { }
1550
1551                 try {
1552                         Array.LastIndexOf<short> (a, 16, -1);
1553                         NUnit.Framework.Assert.Fail ("#2");
1554                 } catch (ArgumentOutOfRangeException) { }
1555         }
1556
1557         [Test]
1558         public void TestLastIndexOf5 ()
1559         {
1560                 char [] a = new char [] {'j', 'i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a', 'j', 'i', 'h'};
1561                 string s;
1562                 int retval;
1563                 bool error = false;
1564
1565                 for (int i = a.Length - 1; i >= 0 ; i--) {
1566                         s = i.ToString ();
1567                         retval = Array.LastIndexOf(a, a [i], i, i + 1);
1568                         if (retval != i)
1569                                 error = true;
1570                 }
1571                 Assert.IsTrue (!error);
1572         }
1573
1574         [Test]
1575         [ExpectedException (typeof (ArgumentOutOfRangeException))]
1576         public void LastIndexOf_StartIndexOverflow ()
1577         {
1578                 // legal - no exception
1579                 byte[] array = new byte [16];
1580                 Array.LastIndexOf (array, this, Int32.MaxValue, 1);
1581         }
1582
1583         [Test]
1584         [ExpectedException (typeof (ArgumentOutOfRangeException))]
1585         public void LastIndexOf_CountOverflow ()
1586         {
1587                 // legal - no exception
1588                 byte[] array = new byte [16];
1589                 Array.LastIndexOf (array, this, 1, Int32.MaxValue);
1590         }
1591
1592         [Test]
1593         public void LastIndexOf_0LengthArray ()
1594         {
1595                 Array array = Array.CreateInstance (typeof (char), 0);
1596                 int idx = Array.LastIndexOf (array, (object) null, -1, 0);
1597                 Assert.IsTrue (idx == -1, "#01");
1598                 idx = Array.LastIndexOf (array, (object) null, -1, 10);
1599                 Assert.IsTrue (idx == -1, "#02");
1600                 idx = Array.LastIndexOf (array, (object) null, -100, 10);
1601                 Assert.IsTrue (idx == -1, "#02");
1602
1603                 array = Array.CreateInstance (typeof (char), 1);
1604                 try {
1605                         Array.LastIndexOf (array, (object) null, -1, 0);
1606                         Assert.Fail ("#04");
1607                 } catch (ArgumentOutOfRangeException e) {
1608                 }
1609                 try {
1610                         Array.LastIndexOf (array, (object) null, -1, 10);
1611                         Assert.Fail ("#05");
1612                 } catch (ArgumentOutOfRangeException e) {
1613                 }
1614                 try {
1615                         Array.LastIndexOf (array, (object) null, -100, 10);
1616                         Assert.Fail ("#06");
1617                 } catch (ArgumentOutOfRangeException e) {
1618                 }
1619         }
1620
1621         [Test]
1622         public void TestReverse() {
1623                 {
1624                         bool errorThrown = false;
1625                         try {
1626                                 Array.Reverse(null);
1627                         } catch (ArgumentNullException) {
1628                                 errorThrown = true;
1629                         }
1630                         Assert.IsTrue (errorThrown, "#L01");
1631                 }
1632                 {
1633                         bool errorThrown = false;
1634                         try {
1635                                 char[,] c = new Char[2,2];
1636                                 Array.Reverse(c);
1637                         } catch (RankException) {
1638                                 errorThrown = true;
1639                         }
1640                         Assert.IsTrue (errorThrown, "#L02");
1641                 }
1642
1643                 char[] c1 = {'a', 'b', 'c', 'd'};
1644                 Array.Reverse(c1);
1645                 Assert.AreEqual ('d', c1[0], "#L03");
1646                 Assert.AreEqual ('c', c1[1], "#L04");
1647                 Assert.AreEqual ('b', c1[2], "#L05");
1648                 Assert.AreEqual ('a', c1[3], "#L06");
1649
1650                 {
1651                         bool errorThrown = false;
1652                         try {
1653                                 Array.Reverse(null, 0, 0);
1654                         } catch (ArgumentNullException) {
1655                                 errorThrown = true;
1656                         }
1657                         Assert.IsTrue (errorThrown, "#L07");
1658                 }
1659                 {
1660                         bool errorThrown = false;
1661                         try {
1662                                 char[,] c = new Char[2,2];
1663                                 Array.Reverse(c, 0, 0);
1664                         } catch (RankException) {
1665                                 errorThrown = true;
1666                         }
1667                         Assert.IsTrue (errorThrown, "#L08");
1668                 }
1669                 //{
1670                 //bool errorThrown = false;
1671                 //try {
1672                 //      char[] c = new Char[2];
1673                 //      Array.Reverse(c, 0, 3);
1674                 //} catch (ArgumentOutOfRangeException) {
1675                 //      errorThrown = true;
1676                 //}
1677                 //Assert.IsTrue (errorThrown, "#L09");
1678                 //}
1679                 //{
1680                 //bool errorThrown = false;
1681                 //try {
1682                 //      char[] c = new Char[2];
1683                 //      Array.Reverse(c, 3, 0);
1684                 //} catch (ArgumentOutOfRangeException) {
1685                 //      errorThrown = true;
1686                 //}
1687                 //Assert.IsTrue (errorThrown, "#L10");
1688                 //}
1689
1690                 char[] c2 = { 'a', 'b', 'c', 'd'};
1691                 Array.Reverse(c2, 1, 2);
1692                 Assert.AreEqual ('a', c2[0], "#L11");
1693                 Assert.AreEqual ('c', c2[1], "#L12");
1694                 Assert.AreEqual ('b', c2[2], "#L13");
1695                 Assert.AreEqual ('d', c2[3], "#L14");
1696         }
1697
1698         [Test]
1699         // #8904
1700         public void ReverseStruct () {
1701                 BStruct[] c3 = new BStruct[2];
1702                 c3 [0] = new BStruct () { i1 = 1, i2 = 2, i3 = 3 };
1703                 c3 [1] = new BStruct () { i1 = 4, i2 = 5, i3 = 6 };
1704                 Array.Reverse (c3);
1705                 Assert.AreEqual (4, c3 [0].i1);
1706                 Assert.AreEqual (5, c3 [0].i2);
1707                 Assert.AreEqual (6, c3 [0].i3);
1708                 Assert.AreEqual (1, c3 [1].i1);
1709                 Assert.AreEqual (2, c3 [1].i2);
1710                 Assert.AreEqual (3, c3 [1].i3);
1711         }
1712
1713         struct BStruct {
1714                 public int i1, i2, i3;
1715         }
1716
1717         [Test]
1718         public void TestSetValue1() {
1719                 {
1720                         bool errorThrown = false;
1721                         try {
1722                                 char[,] c = new Char[2,2];
1723                                 c.SetValue("buh", 1);
1724                         } catch (ArgumentException) {
1725                                 errorThrown = true;
1726                         }
1727                         Assert.IsTrue (errorThrown, "#M01");
1728                 }
1729                 {
1730                         bool errorThrown = false;
1731                         try {
1732                                 char[] c = {'a', 'b', 'c'};
1733                                 c.SetValue("buh", -1);
1734                         } catch (IndexOutOfRangeException) {
1735                                 errorThrown = true;
1736                         }
1737                         Assert.IsTrue (errorThrown, "#M02");
1738                 }
1739                 {
1740                         bool errorThrown = false;
1741                         try {
1742                                 char[] c = {'a', 'b', 'c'};
1743                                 c.SetValue("buh", 4);
1744                         } catch (IndexOutOfRangeException) {
1745                                 errorThrown = true;
1746                         }
1747                         Assert.IsTrue (errorThrown, "#M03");
1748                 }
1749
1750                 char[] c1 = {'a', 'b', 'c', 'd'};
1751                 char[] c2 = new char[4];
1752                 for (int i = 0; i < c1.Length; i++) {
1753                         c2.SetValue(c1[i], i);
1754                 }
1755                 for (int i = 0; i < c1.Length; i++) {
1756                         Assert.AreEqual (c1[i], c2[i], "#M04(" + i + ")");
1757                 }
1758
1759                 int[] c3 = { 1, 2, 3 };
1760                 long[] c4 = new long [3];
1761
1762                 for (int i = 0; i < c3.Length; i++)
1763                         c4.SetValue (c3 [i], i);
1764
1765                 try {
1766                         c3.CopyTo (c4, 0);
1767                 } catch (Exception e) {
1768                         Assert.Fail ("c3.CopyTo(): e=" + e);
1769                 }
1770                 for (int i = 0; i < c3.Length; i++)
1771                         Assert.IsTrue (c3[i] == c4[i], "#M05(" + i + ")");
1772
1773                 Object[] c5 = new Object [3];
1774                 long[] c6 = new long [3];
1775
1776                 try {
1777                         c4.CopyTo (c5, 0);
1778                 } catch (Exception e) {
1779                         Assert.Fail ("c4.CopyTo(): e=" + e);
1780                 }
1781
1782                 try {
1783                         c5.CopyTo (c6, 0);
1784                 } catch (Exception e) {
1785                         Assert.Fail ("c5.CopyTo(): e=" + e);
1786                 }
1787                 // for (int i = 0; i < c5.Length; i++)
1788                 // Assert.IsTrue (c5[i] == c6[i], "#M06(" + i + ")");
1789         }
1790
1791         [Test]
1792         public void TestSetValue2() {
1793                 {
1794                         bool errorThrown = false;
1795                         try {
1796                                 char[] c = new Char[2];
1797                                 c.SetValue("buh", 1,1);
1798                         } catch (ArgumentException) {
1799                                 errorThrown = true;
1800                         }
1801                         Assert.IsTrue (errorThrown, "#M21");
1802                 }
1803                 {
1804                         bool errorThrown = false;
1805                         try {
1806                                 char[,] c = new Char[2,2];
1807                                 c.SetValue("buh", -1, 1);
1808                         } catch (IndexOutOfRangeException) {
1809                                 errorThrown = true;
1810                         }
1811                         Assert.IsTrue (errorThrown, "#M22");
1812                 }
1813                 {
1814                         bool errorThrown = false;
1815                         try {
1816                                 char[,] c = new Char[2,2];
1817                                 c.SetValue("buh", 4,1);
1818                         } catch (IndexOutOfRangeException) {
1819                                 errorThrown = true;
1820                         }
1821                         Assert.IsTrue (errorThrown, "#M23");
1822                 }
1823
1824                 char[,] c1 = new Char[4,6];
1825                 char[,] c2 = new Char[4,6];
1826                 for (int i = 0; i < 24; i++) {
1827                         int first = i / 6;
1828                         int second = i % 6;
1829                         c1[first,second] = (char)(((int)'a')+i);
1830                         c2.SetValue(c1[first,second], first, second);
1831                 }
1832                 for (int i = 0; i < c1.GetLength(0); i++) {
1833                         for (int j = 0; j < c1.GetLength(1); j++) {
1834                                 Assert.AreEqual (c1[i, j], c2[i, j], "#M24(" + i + "," + j + ")");
1835                         }
1836                 }
1837         }
1838
1839         [Test]
1840         public void TestSetValue3() {
1841                 {
1842                         bool errorThrown = false;
1843                         try {
1844                                 char[] c = new Char[2];
1845                                 c.SetValue("buh", 1,1,1);
1846                         } catch (ArgumentException) {
1847                                 errorThrown = true;
1848                         }
1849                         Assert.IsTrue (errorThrown, "#M41");
1850                 }
1851                 {
1852                         bool errorThrown = false;
1853                         try {
1854                                 char[,,] c = new Char[2,2,2];
1855                                 c.SetValue("buh", -1, 1, 1);
1856                         } catch (IndexOutOfRangeException) {
1857                                 errorThrown = true;
1858                         }
1859                         Assert.IsTrue (errorThrown, "#M42");
1860                 }
1861                 {
1862                         bool errorThrown = false;
1863                         try {
1864                                 char[,,] c = new Char[2,2,2];
1865                                 c.SetValue("buh", 4,1,1);
1866                         } catch (IndexOutOfRangeException) {
1867                                 errorThrown = true;
1868                         }
1869                         Assert.IsTrue (errorThrown, "#M43");
1870                 }
1871
1872                 char[,,] c1 = new Char[4,2,3];
1873                 char[,,] c2 = new Char[4,2,3];
1874                 for (int i = 0; i < 24; i++) {
1875                         int first = i / 6;
1876                         int remains = i % 6;
1877                         int second = remains / 3;
1878                         int third = remains % 3;
1879                         c1[first,second, third] = (char)(((int)'a')+i);
1880                         c2.SetValue(c1[first, second, third], first, second, third);
1881                 }
1882                 for (int i = 0; i < c1.GetLength(0); i++) {
1883                         for (int j = 0; j < c1.GetLength(1); j++) {
1884                                 for (int k = 0; k < c1.GetLength(2); k++) {
1885                                         Assert.AreEqual (c1[i, j, k], c2[i, j, k], "#M44(" + i + "," + j + " )");
1886                                 }
1887                         }
1888                 }
1889         }
1890
1891         [Test]
1892         [ExpectedException (typeof (ArgumentNullException))]
1893         public void TestSetValueLongArray ()
1894         {
1895                 char[] c = new Char[2];
1896                 c.SetValue("buh", (long [])null);
1897         }
1898
1899         [Test]
1900         public void TestSetValueN() {
1901                 {
1902                         bool errorThrown = false;
1903                         try {
1904                                 char[] c = new Char[2];
1905                                 c.SetValue("buh", (int [])null);
1906                         } catch (ArgumentNullException) {
1907                                 errorThrown = true;
1908                         }
1909                         Assert.IsTrue (errorThrown, "#M61a");
1910                 }
1911                 {
1912                         bool errorThrown = false;
1913                         try {
1914                                 char[] c = new Char[2];
1915                                 int[] coords = {1, 1};
1916                                 c.SetValue("buh", coords);
1917                         } catch (ArgumentException) {
1918                                 errorThrown = true;
1919                         }
1920                         Assert.IsTrue (errorThrown, "#M62");
1921                 }
1922                 {
1923                         bool errorThrown = false;
1924                         try {
1925                                 char[,] c = new Char[2,2];
1926                                 int[] coords = {-1, 1};
1927                                 c.SetValue("buh", coords);
1928                         } catch (IndexOutOfRangeException) {
1929                                 errorThrown = true;
1930                         }
1931                         Assert.IsTrue (errorThrown, "#M63");
1932                 }
1933                 {
1934                         bool errorThrown = false;
1935                         try {
1936                                 char[,] c = new Char[2,2];
1937                                 int[] coords = {4, 1};
1938                                 c.SetValue("buh", coords);
1939                         } catch (IndexOutOfRangeException) {
1940                                 errorThrown = true;
1941                         }
1942                         Assert.IsTrue (errorThrown, "#M64");
1943                 }
1944
1945                 char[,] c1 = new Char[4,6];
1946                 char[,] c2 = new Char[4,6];
1947                 for (int i = 0; i < 24; i++) {
1948                         int first = i / 6;
1949                         int second = i % 6;
1950                         c1[first,second] = (char)(((int)'a')+i);
1951                         int[] coords = {first, second};
1952                         c2.SetValue(c1[first,second], coords);
1953                 }
1954                 for (int i = 0; i < c1.GetLength(0); i++) {
1955                         for (int j = 0; j < c1.GetLength(1); j++) {
1956                                 Assert.AreEqual (c1[i, j], c2[i, j], "#M65(" + i + "," + j + ")");
1957                         }
1958                 }
1959         }
1960
1961         [Test]
1962         public void TestSetValue4() {
1963                 {
1964                         int[] c1 = { 1, 2, 3 };
1965                         long[] c2 = new long [3];
1966
1967                         for (int i = 0; i < c1.Length; i++)
1968                                 c2.SetValue (c1 [i], i);
1969
1970                         for (int i = 0; i < c1.Length; i++) {
1971                                 Assert.IsTrue (c1[i] == c2[i], "#M81(" + i + ")");
1972                                 Assert.AreEqual (typeof (long), c2[i].GetType (), "#M82(" + i + ")");
1973                         }
1974                 }
1975                 {
1976                         long[] c1 = { 1, 2, 3 };
1977                         int[] c2 = new int [3];
1978                         bool errorThrown = false;
1979                         try {
1980                                 c2.SetValue (c1 [0], 0);
1981                         } catch (ArgumentException) {
1982                                 errorThrown = true;
1983                         }
1984                         Assert.IsTrue (errorThrown, "#M83");
1985                 }
1986                 {
1987                         int[] c1 = { 1, 2, 3 };
1988                         Object[] c2 = new Object [3];
1989
1990                         for (int i = 0; i < c1.Length; i++)
1991                                 c2.SetValue (c1 [i], i);
1992
1993                         for (int i = 0; i < c1.Length; i++)
1994                                 Assert.AreEqual (c1[i], Convert.ToInt32 (c2[i]), "#M84(" + i + ")");
1995                 }
1996                 {
1997                         Object[] c1 = new Object [3];
1998                         Object[] c2 = new Object [3];
1999                         c1[0] = new Object ();
2000
2001                         for (int i = 0; i < c1.Length; i++)
2002                                 c2.SetValue (c1 [i], i);
2003
2004                         for (int i = 0; i < c1.Length; i++)
2005                                 Assert.AreEqual (c1[i], c2[i], "#M85(" + i + ")");
2006                 }
2007                 {
2008                         Object[] c1 = new Object [3];
2009                         string[] c2 = new String [3];
2010                         string test = "hello";
2011                         c1[0] = test;
2012
2013                         c2.SetValue (c1 [0], 0);
2014                         Assert.AreEqual (c1[0], c2[0], "#M86");
2015                         Assert.AreEqual ("hello", c2[0], "#M87");
2016                 }
2017                 {
2018                         char[] c1 = { 'a', 'b', 'c' };
2019                         string[] c2 = new string [3];
2020                         try {
2021                                 c2.SetValue (c1 [0], 0);
2022                                 Assert.Fail ("#M88");
2023                         } catch (InvalidCastException) {}
2024                 }
2025                 {
2026                         Single[] c1 = { 1.2F, 2.3F, 3.4F, 4.5F };
2027                         long[] c2 = new long [3];
2028                         try {
2029                                 c2.SetValue (c1 [0], 0);
2030                                 Assert.Fail ("#M89");
2031                         } catch (ArgumentException) {}
2032                 }
2033                 {
2034                         Type[] types = {
2035                                 typeof (Boolean),
2036                                 typeof (Byte),
2037                                 typeof (Char),
2038                                 typeof (Double),
2039                                 typeof (Int16),
2040                                 typeof (Int32),
2041                                 typeof (Int64),
2042                                 typeof (SByte),
2043                                 typeof (Single),
2044                                 typeof (UInt16),
2045                                 typeof (UInt32),
2046                                 typeof (UInt64)
2047                         };
2048
2049                         bool v1 = true;
2050                         Byte v2 = 1;
2051                         Char v3 = 'a';
2052                         Double v4 = -1.2;
2053                         Int16 v5 = -32;
2054                         Int32 v6 = -234;
2055                         Int64 v7 = -34523;
2056                         SByte v8 = -1;
2057                         Single v9 = -4.8F;
2058                         UInt16 v10 = 24234;
2059                         UInt32 v11 = 235354;
2060                         UInt64 v12 = 234552;
2061
2062                         Object[] va1 = { v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12 };
2063                         Object[] va2 = { "true", "1", "a", "-1.2", "-32", "-234", "-34523", "-1",
2064                                          "-4.8F", "24234", "235354", "234552" };
2065
2066                         Object[][] vt = { va1, va1, va1, va1, va1, va1, va1, va1, va1, va1, va1, va1 };
2067
2068                         int[] arg_ex = {
2069                                 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2070                                 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
2071                                 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0,
2072                                 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,
2073                                 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1,
2074                                 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1,
2075                                 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,
2076                                 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1,
2077                                 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1,
2078                                 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0,
2079                                 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0,
2080                                 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0
2081                         };
2082
2083                         // SetValue
2084
2085                         for (int i = 0; i < types.Length; i++) {
2086                                 for (int j = 0; j < types.Length; j++) {
2087                                         Array array = Array.CreateInstance (types [j], 2);
2088
2089                                         Object value = vt[j][i];
2090
2091                                         bool errorThrown = false;
2092                                         try {
2093                                                 array.SetValue (value, 0);
2094                                         } catch (ArgumentException) {
2095                                                 errorThrown = true;
2096                                         }
2097
2098                                         int ex_index = (i * types.Length) + j;
2099
2100                                         Assert.AreEqual (errorThrown, arg_ex [ex_index] == 1, "#M90(" + types [i] + "," + types [j] + ")");
2101                                 }
2102                         }
2103
2104                         for (int i = 0; i < types.Length; i++) {
2105                                 String[] array = new String [2];
2106
2107                                 Object value = va1 [i];
2108
2109                                 bool errorThrown = false;
2110                                 try {
2111                                         array.SetValue (value, 0);
2112                                 } catch (InvalidCastException) {
2113                                         errorThrown = true;
2114                                 }
2115
2116                                 Assert.IsTrue (errorThrown, "#M91(" + types [i] + ")");
2117                         }
2118
2119                         for (int i = 0; i < types.Length; i++) {
2120                                 Array array = Array.CreateInstance (types [i], 2);
2121
2122                                 Object value = va2 [i];
2123
2124                                 bool errorThrown = false;
2125                                 try {
2126                                         array.SetValue (value, 0);
2127                                 } catch (InvalidCastException) {
2128                                         errorThrown = true;
2129                                 }
2130
2131                                 Assert.IsTrue (errorThrown, "#M92(" + types [i] + ")");
2132                         }
2133
2134                         for (int i = 0; i < types.Length; i++) {
2135                                 Array array = Array.CreateInstance (types [i], 2);
2136
2137                                 Object value = null;
2138
2139                                 bool errorThrown = false;
2140                                 try {
2141                                         array.SetValue (value, 0);
2142                                 } catch (InvalidCastException) {
2143                                         errorThrown = true;
2144                                 }
2145
2146                                 Assert.IsTrue (!errorThrown, "#M93(" + types [i] + ")");
2147                         }
2148
2149                         // Copy
2150
2151                         for (int i = 0; i < types.Length; i++) {
2152                                 for (int j = 0; j < types.Length; j++) {
2153                                         Array source = Array.CreateInstance (types [i], 2);
2154                                         Array array = Array.CreateInstance (types [j], 2);
2155
2156                                         source.SetValue (vt[j][i], 0);
2157                                         source.SetValue (vt[j][i], 1);
2158
2159                                         bool errorThrown = false;
2160                                         try {
2161                                                 Array.Copy (source, array, 2);
2162                                         } catch (ArrayTypeMismatchException) {
2163                                                 errorThrown = true;
2164                                         }
2165
2166                                         int ex_index = (i * types.Length) + j;
2167
2168                                         Assert.AreEqual (errorThrown, arg_ex [ex_index] == 1, "#M94(" + types [i] + "," + types [j] + ")");
2169                                 }
2170                         }
2171
2172                         for (int i = 0; i < types.Length; i++) {
2173                                 Array source = Array.CreateInstance (types [i], 2);
2174                                 String[] array = new String [2];
2175
2176                                 source.SetValue (va1 [i], 0);
2177                                 source.SetValue (va1 [i], 1);
2178
2179                                 bool errorThrown = false;
2180                                 try {
2181                                         Array.Copy (source, array, 2);
2182                                 } catch (ArrayTypeMismatchException) {
2183                                         errorThrown = true;
2184                                 }
2185
2186                                 Assert.IsTrue (errorThrown, "#M95(" + types [i] + ")");
2187                         }
2188
2189                         for (int i = 0; i < types.Length; i++) {
2190                                 String[] source = new String [2];
2191                                 Array array = Array.CreateInstance (types [i], 2);
2192
2193                                 source.SetValue (va2 [i], 0);
2194                                 source.SetValue (va2 [i], 1);
2195
2196                                 bool errorThrown = false;
2197                                 try {
2198                                         Array.Copy (source, array, 2);
2199                                 } catch (ArrayTypeMismatchException) {
2200                                         errorThrown = true;
2201                                 }
2202
2203                                 Assert.IsTrue (errorThrown, "#M96(" + types [i] + ")");
2204                         }
2205                 }
2206         }
2207
2208         [Test]
2209         public void TestSort() {
2210                 {
2211                         bool errorThrown = false;
2212                         try {
2213                                 Array.Sort(null);
2214                         } catch (ArgumentNullException) {
2215                                 errorThrown = true;
2216                         }
2217                         Assert.IsTrue (errorThrown, "#N01");
2218                 }
2219                 {
2220                         bool errorThrown = false;
2221                         try {
2222                                 Array.Sort(null, 0, 1);
2223                         } catch (ArgumentNullException) {
2224                                 errorThrown = true;
2225                         }
2226                         Assert.IsTrue (errorThrown, "#N02");
2227                 }
2228                 {
2229                         bool errorThrown = false;
2230                         try {
2231                                 char[] c1 = new Char[2];
2232                                 Array.Sort(null, c1);
2233                         } catch (ArgumentNullException) {
2234                                 errorThrown = true;
2235                         }
2236                         Assert.IsTrue (errorThrown, "#N03");
2237                 }
2238                 {
2239                         bool errorThrown = false;
2240                         try {
2241                                 char[] c1 = new Char[2];
2242                                 Array.Sort(null, c1, 0, 1);
2243                         } catch (ArgumentNullException) {
2244                                 errorThrown = true;
2245                         }
2246                         Assert.IsTrue (errorThrown, "#N04");
2247                 }
2248                 {
2249                         int tc = 5;
2250                         char[] arr = {'d', 'b', 'f', 'e', 'a', 'c'};
2251
2252                         try {
2253                                 Array.Sort (null, 0, 1);
2254                                 Assert.Fail ("#N" + tc.ToString ());
2255                         }
2256                         catch (ArgumentException) {}
2257                         catch (Exception) { Assert.Fail ("#N" + tc.ToString ()); }
2258                         tc++;
2259
2260                         try {
2261                                 Array.Sort (arr, -1, 3);
2262                                 Assert.Fail ("#N" + tc.ToString ());
2263                         }
2264                         catch (ArgumentException) {}
2265                         catch (Exception) { Assert.Fail ("#N" + tc.ToString ()); }
2266                         tc++;
2267
2268                         try {
2269                                 Array.Sort (arr, 1, -3);
2270                                 Assert.Fail ("#N" + tc.ToString ());
2271                         }
2272                         catch (ArgumentException) {}
2273                         catch (Exception) { Assert.Fail ("#N" + tc.ToString ()); }
2274                         tc++;
2275
2276                         try {
2277                                 Array.Sort (arr, arr.Length, arr.Length + 2);
2278                                 Assert.Fail ("#N" + tc.ToString ());
2279                         }
2280                         catch (ArgumentException) {}
2281                         catch (Exception) { Assert.Fail ("#N" + tc.ToString ()); }
2282                 }
2283
2284                 // note: null second array => just sort first array
2285                 char[] starter = {'d', 'b', 'f', 'e', 'a', 'c'};
2286                 int[] starter1 = {1,2,3,4,5,6};
2287                 {
2288                         char[] c1 = (char[])starter.Clone();
2289                         Array.Sort(c1);
2290                         Assert.AreEqual ('a', c1[0], "#N21");
2291                         Assert.AreEqual ('b', c1[1], "#N22");
2292                         Assert.AreEqual ('c', c1[2], "#N23");
2293                         Assert.AreEqual ('d', c1[3], "#N24");
2294                         Assert.AreEqual ('e', c1[4], "#N25");
2295                         Assert.AreEqual ('f', c1[5], "#N26");
2296                 }
2297                 {
2298                         char[] c1 = (char[])starter.Clone();
2299                         int[] i1 = (int[])starter1.Clone();
2300                         Array.Sort(c1, i1);
2301                         Assert.AreEqual ('a', c1[0], "#N41");
2302                         Assert.AreEqual ('b', c1[1], "#N42");
2303                         Assert.AreEqual ('c', c1[2], "#N43");
2304                         Assert.AreEqual ('d', c1[3], "#N44");
2305                         Assert.AreEqual ('e', c1[4], "#N45");
2306                         Assert.AreEqual ('f', c1[5], "#N46");
2307                         Assert.AreEqual (5, i1[0], "#N47");
2308                         Assert.AreEqual (2, i1[1], "#N48");
2309                         Assert.AreEqual (6, i1[2], "#N49");
2310                         Assert.AreEqual (1, i1[3], "#N50");
2311                         Assert.AreEqual (4, i1[4], "#N51");
2312                         Assert.AreEqual (3, i1[5], "#N52");
2313                 }
2314                 {
2315                         char[] c1 = (char[])starter.Clone();
2316                         Array.Sort(c1, 1, 4);
2317                         Assert.AreEqual ('d', c1[0], "#N61");
2318                         Assert.AreEqual ('a', c1[1], "#N62");
2319                         Assert.AreEqual ('b', c1[2], "#N63");
2320                         Assert.AreEqual ('e', c1[3], "#N64");
2321                         Assert.AreEqual ('f', c1[4], "#N65");
2322                         Assert.AreEqual ('c', c1[5], "#N66");
2323                 }
2324                 {
2325                         char[] c1 = (char[])starter.Clone();
2326                         int[] i1 = (int[])starter1.Clone();
2327                         Array.Sort(c1, i1, 1, 4);
2328                         Assert.AreEqual ('d', c1[0], "#N81");
2329                         Assert.AreEqual ('a', c1[1], "#N82");
2330                         Assert.AreEqual ('b', c1[2], "#N83");
2331                         Assert.AreEqual ('e', c1[3], "#N84");
2332                         Assert.AreEqual ('f', c1[4], "#N85");
2333                         Assert.AreEqual ('c', c1[5], "#N86");
2334                         Assert.AreEqual (1, i1[0], "#N87");
2335                         Assert.AreEqual (5, i1[1], "#N88");
2336                         Assert.AreEqual (2, i1[2], "#N89");
2337                         Assert.AreEqual (4, i1[3], "#N90");
2338                         Assert.AreEqual (3, i1[4], "#N91");
2339                         Assert.AreEqual (6, i1[5], "#N92");
2340                 }
2341
2342                 {
2343                         // #648828
2344                         double[] a = new double[115];
2345                         int[] b = new int[256];
2346                         Array.Sort<double, int> (a, b, 0, 115);
2347                 }
2348
2349                 /* Check that ulong[] is not sorted as long[] */
2350                 {
2351                         string[] names = new string[] {
2352                                 "A", "B", "C", "D", "E"
2353                         };
2354
2355                         ulong[] arr = new ulong [] {
2356                                 5,
2357                                 unchecked((ulong)0xffffFFFF00000000),
2358                                         0,
2359                                                 0x7FFFFFFFffffffff,
2360                                                 100
2361                                                 };
2362
2363                         Array a = arr;
2364                         Array.Sort (a, names, null);
2365                         Assert.AreEqual (0, a.GetValue (0));
2366                 }
2367         }
2368
2369         [Test] // #616416
2370         public void SortNonGenericDoubleItems () {
2371             double[] doubleValues = new double[11];
2372
2373                         doubleValues[0] = 0.221788066253601;
2374                         doubleValues[1] = 0.497278285809481;
2375                         doubleValues[2] = 0.100565033883643;
2376                         doubleValues[3] = 0.0433309347749905;
2377                         doubleValues[4] = 0.00476726438463812;
2378                         doubleValues[5] = 0.1354609735456;
2379                         doubleValues[6] = 0.57690356588135;
2380                         doubleValues[7] = 0.466239434334826;
2381                         doubleValues[8] = 0.409741461978934;
2382                         doubleValues[9] = 0.0112412763949565;
2383                         doubleValues[10] = 0.668704347674307;
2384
2385             int[] indices = new int[11];
2386             indices[0] = 0;
2387             indices[1] = 1;
2388             indices[2] = 2;
2389             indices[3] = 3;
2390             indices[4] = 4;
2391             indices[5] = 5;
2392             indices[6] = 6;
2393             indices[7] = 7;
2394             indices[8] = 8;
2395             indices[9] = 9;
2396             indices[10] = 10;
2397
2398                         Array.Sort ((Array)doubleValues, (Array)indices);
2399                         Assert.AreEqual (4, indices [0]);
2400         }
2401
2402         [Test]
2403         public void TestInitializeEmpty()
2404         {
2405                 bool catched=false;
2406                 int[] a = {};
2407                 try
2408                 {
2409                         a.Initialize();
2410                 }
2411                 catch(Exception)
2412                 {
2413                         catched=true;
2414                 }
2415                 Assert.IsTrue (!catched, "#TI01");
2416         }
2417
2418         [Test]
2419         public void TestInitializeInt()
2420         {
2421                 int[] a = {1,2,0};
2422                 a.Initialize();
2423                 int[] b = {1,2,0};
2424                 for(int i=a.GetLowerBound(0);i<=a.GetUpperBound(0);i++)
2425                 {
2426                         Assert.AreEqual (a[i], b[i], "#TI02 " + i);
2427                 }
2428         }
2429
2430         [Test]
2431         public void TestInitializeDouble()
2432         {
2433                 double[] a = {1.0,2.0,0.0};
2434                 a.Initialize();
2435                 double[] b = {1.0,2.0,0.0};
2436                 for(int i=a.GetLowerBound(0);i<=a.GetUpperBound(0);i++)
2437                 {
2438                         Assert.AreEqual (a[i], b[i], "#TI03 " + i);
2439                 }
2440         }
2441
2442         [Test]
2443         public void TestInitializeFloat()
2444         {
2445                 float[] a = {1.0F,2.0F,0.0F};
2446                 a.Initialize();
2447                 float[] b = {1.0F,2.0F,0.0F};
2448                 for(int i=a.GetLowerBound(0);i<=a.GetUpperBound(0);i++)
2449                 {
2450                         Assert.AreEqual (a[i], b[i], "#TI04 " + i);
2451                 }
2452         }
2453
2454         [Test]
2455         public void TestInitializeChar()
2456         {
2457                 char[] a = {'1','.','0','F','2','.','0','F'};
2458                 a.Initialize();
2459                 char[] b = {'1','.','0','F','2','.','0','F'};
2460                 for(int i=a.GetLowerBound(0);i<=a.GetUpperBound(0);i++)
2461                 {
2462                         Assert.AreEqual (a[i], b[i], "#TI05 " + i);
2463                 }
2464         }
2465
2466         [Test]
2467         public void TestInitializeString()
2468         {
2469                 string[] a = {"hola","adios","menos","mas"};
2470                 a.Initialize();
2471                 string[] b = {"hola","adios","menos","mas"};
2472                 for(int i=a.GetLowerBound(0);i<=a.GetUpperBound(0);i++)
2473                 {
2474                         Assert.AreEqual (a[i], b[i], "#TI06 " + i);
2475                 }
2476         }
2477
2478         [Test]
2479         public void TestInitializeEnum()
2480         {
2481                 enua[] a = {enua.hola,enua.adios,enua.menos,enua.mas};
2482                 a.Initialize();
2483                 enua[] b = {enua.hola,enua.adios,enua.menos,enua.mas};
2484                 for(int i=a.GetLowerBound(0);i<=a.GetUpperBound(0);i++)
2485                 {
2486                         Assert.AreEqual (a[i], b[i], "#TI07 " + i);
2487                 }
2488         }
2489
2490         [Test]
2491         public void TestInitializeIntNI()
2492         {
2493                 int[] a = new int[20];
2494                 a.Initialize();
2495                 foreach(int b in a)
2496                 {
2497                         Assert.AreEqual (b, 0, "#TI08");
2498                 }
2499         }
2500
2501         [Test]
2502         public void TestInitializeCharNI()
2503         {
2504                 char[] a = new char[20];
2505                 a.Initialize();
2506                 foreach(char b in a)
2507                 {
2508                         Assert.AreEqual (b, 0, "#TI09");
2509                 }
2510         }
2511
2512         [Test]
2513         public void TestInitializeDoubleNI()
2514         {
2515                 double[] a = new double[20];
2516                 a.Initialize();
2517                 foreach(double b in a)
2518                 {
2519                         Assert.AreEqual (b, 0.0, "#TI09");
2520                 }
2521         }
2522
2523         [Test]
2524         public void TestInitializeStringNI()
2525         {
2526                 string[] a = new string[20];
2527                 a.Initialize();
2528                 foreach(string b in a)
2529                 {
2530                         Assert.AreEqual (b, null, "#TI10");
2531                 }
2532         }
2533
2534         [Test]
2535         public void TestInitializeObjectNI()
2536         {
2537                 object[] a = new object[20];
2538                 a.Initialize();
2539                 foreach(object b in a)
2540                 {
2541                         Assert.AreEqual (b, null, "#TI11");
2542                 }
2543         }
2544
2545         [Test]
2546         public void TestInitializeAClassNI()
2547         {
2548                 AClass[] a = new AClass[20];
2549                 a.Initialize();
2550                 foreach(AClass b in a)
2551                 {
2552                         Assert.AreEqual (b, null, "#TI12");
2553                 }
2554         }
2555
2556
2557         [Test]
2558         public void TestInitializeAStructNI()
2559         {
2560                 AStruct[] a = new AStruct[20];
2561                 a.Initialize();
2562                 foreach(AStruct b in a)
2563                 {
2564                         Assert.AreEqual (b, new AStruct(), "#TI14");
2565                 }
2566         }
2567
2568         [Test]
2569         public void TestInitializeAStruct()
2570         {
2571                 AStruct[] a = new AStruct[3];
2572                 a[1].a = "ADIOS";
2573                 a[1].s = "HOLA";
2574                 a.Initialize();
2575                 AStruct[] b = new AStruct[3];
2576                 b[1].a = "ADIOS";
2577                 b[1].s = "HOLA";
2578                 for(int i=a.GetLowerBound(0);i<=a.GetUpperBound(0);i++)
2579                 {
2580                         Assert.AreEqual (a[i], b[i], "#TI15 " + i);
2581                 }
2582         }
2583
2584         [Test]
2585         public void TestInitializeDateTimeNI()
2586         {
2587                 DateTime[] a = new DateTime[20];
2588                 a.Initialize();
2589                 foreach(DateTime b in a)
2590                 {
2591                         Assert.AreEqual (b, new DateTime(), "#TI16");
2592                 }
2593         }
2594
2595         [Test]
2596         [ExpectedException (typeof (ArgumentNullException))]
2597         public void MoreSort1 ()
2598         {
2599                 Array.Sort (null, 0, 1);
2600         }
2601
2602         [Test]
2603         [ExpectedException (typeof (ArgumentOutOfRangeException))]
2604         public void MoreSort2 ()
2605         {
2606                 Array.Sort (arrsort, -1, 3);
2607         }
2608
2609         [Test]
2610         [ExpectedException (typeof (ArgumentOutOfRangeException))]
2611         public void MoreSort3 ()
2612         {
2613                 Array.Sort (arrsort, 1, -3);
2614         }
2615
2616         [Test]
2617         [ExpectedException (typeof (ArgumentException))]
2618         public void MoreSort4 ()
2619         {
2620                 Array.Sort (arrsort, arrsort.Length, arrsort.Length + 2);
2621         }
2622
2623         [Test]
2624         [ExpectedException (typeof (RankException))]
2625         public void MoreSort5 ()
2626         {
2627                 char [,] arr = new char [,] {{'a'}, {'b'}};
2628                 Array.Sort (arr, 0, 1);
2629         }
2630
2631         [Test]
2632         public void MoreSort6 ()
2633         {
2634                 Array.Sort (arrsort, 0, 0);
2635         }
2636
2637         [Test]
2638         [ExpectedException (typeof (ArgumentException))]
2639         public void MoreSort7 ()
2640         {
2641                 Array.Sort (arrsort, arrsort.Length - 1, 2);
2642         }
2643
2644         [Test]
2645         [ExpectedException (typeof (ArgumentException))]
2646         public void MoreSort8 ()
2647         {
2648                 Array.Sort (arrsort, 0, arrsort.Length + 1);
2649         }
2650
2651         [Test]
2652         public void MoreSort9 ()
2653         {
2654                 Array.Sort (arrsort, null, 0, arrsort.Length, null);
2655         }
2656
2657         [Test]
2658         [ExpectedException (typeof (InvalidOperationException))]
2659         public void MoreSort10 ()
2660         {
2661                 object [] array = {true, 'k', SByte.MinValue, Byte.MinValue, (short) 2, 634, (long) 436, (float) 1.1, 1.23, "Hello World"};
2662                 Array.Sort (array, (IComparer) null);
2663         }
2664
2665         [Test] // bug #81941
2666         public void Sort ()
2667         {
2668                 double [] a = new double [2] { 0.9, 0.3 };
2669                 uint [] b = new uint [2] { 4, 7 };
2670                 Array.Sort (a, b);
2671                 Assert.AreEqual (0.3, a [0], "#1");
2672                 Assert.AreEqual (0.9, a [1], "#2");
2673                 Assert.AreEqual (7, b [0], "#3");
2674                 Assert.AreEqual (4, b [1], "#4");
2675         }
2676
2677         [Test]
2678         public void ClearJaggedArray ()
2679         {
2680                 byte[][] matrix = new byte [8][];
2681                 for (int i=0; i < 8; i++) {
2682                         matrix [i] = new byte [8];
2683                         for (int j=0; j < 8; j++) {
2684                                 matrix [i][j] = 1;
2685                         }
2686                 }
2687                 Array.Clear (matrix, 0, 8);
2688                 for (int i=0; i < 8; i++) {
2689                         Assert.IsNull (matrix [i], i.ToString ());
2690                 }
2691         }
2692
2693         [Test]
2694         public void ClearMultidimentionalArray ()
2695         {
2696                 byte[,] matrix = new byte [2,2] { {1, 1}, {2, 2} };
2697                 Array.Clear (matrix, 0, 2);
2698                 Assert.AreEqual (0, matrix [0, 0], "0,0");
2699                 Assert.AreEqual (0, matrix [0, 1], "0,1");
2700                 Assert.AreEqual (2, matrix [1, 0], "1,0");
2701                 Assert.AreEqual (2, matrix [1, 1], "1,1");
2702         }
2703
2704         [Test]
2705         [ExpectedException (typeof (IndexOutOfRangeException))]
2706         public void ClearOutsideMultidimentionalArray ()
2707         {
2708                 byte[,] matrix = new byte [2,2] { {1, 1}, {2, 2} };
2709                 Array.Clear (matrix, 0, 5);
2710         }
2711
2712         [Test]
2713         [ExpectedException (typeof (IndexOutOfRangeException))]
2714         public void Clear_IndexOverflow ()
2715         {
2716                 byte[] array = new byte [16];
2717                 Array.Clear (array, 4, Int32.MaxValue);
2718         }
2719
2720         [Test]
2721         [ExpectedException (typeof (IndexOutOfRangeException))]
2722         public void Clear_LengthOverflow ()
2723         {
2724                 byte[] array = new byte [16];
2725                 Array.Clear (array, Int32.MaxValue, 4);
2726         }
2727
2728         [Test]
2729         [ExpectedException (typeof (ArgumentException))]
2730         public void Copy_SourceIndexOverflow ()
2731         {
2732                 byte[] array = new byte [16];
2733                 Array.Copy (array, Int32.MaxValue, array, 8, 8);
2734         }
2735
2736         [Test]
2737         [ExpectedException (typeof (ArgumentException))]
2738         public void Copy_DestinationIndexOverflow ()
2739         {
2740                 byte[] array = new byte [16];
2741                 Array.Copy (array, 8, array, Int32.MaxValue, 8);
2742         }
2743
2744         [Test]
2745         [ExpectedException (typeof (ArgumentException))]
2746         public void Copy_LengthOverflow ()
2747         {
2748                 byte[] array = new byte [16];
2749                 Array.Copy (array, 8, array, 8, Int32.MaxValue);
2750         }
2751
2752         [Test]
2753         [ExpectedException (typeof (ArgumentException))]
2754         public void Reverse_IndexOverflow ()
2755         {
2756                 byte[] array = new byte [16];
2757                 Array.Reverse (array, Int32.MaxValue, 8);
2758         }
2759
2760         [Test]
2761         [ExpectedException (typeof (ArgumentException))]
2762         public void Reverse_LengthOverflow ()
2763         {
2764                 byte[] array = new byte [16];
2765                 Array.Reverse (array, 8, Int32.MaxValue);
2766         }
2767
2768         public struct CharX : IComparable {
2769                 public char c;
2770
2771                 public CharX (char c)
2772                 {
2773                         this.c = c;
2774                 }
2775
2776                 public int CompareTo (object obj)
2777                 {
2778                         if (obj is CharX)
2779                                 return c.CompareTo (((CharX) obj).c);
2780                         else
2781                                 return c.CompareTo (obj);
2782                 }
2783         }
2784
2785         [Test]
2786         public void BinarySearch_ArgPassingOrder ()
2787         {
2788                 //
2789                 // This tests that arguments are passed to the comprer in the correct
2790                 // order. The IComparable of the *array* elements must get called, not
2791                 // that of the search object.
2792                 //
2793                 CharX [] x = { new CharX ('a'), new CharX ('b'), new CharX ('c') };
2794                 Assert.AreEqual (1, Array.BinarySearch (x, 'b'));
2795         }
2796
2797         class Comparer: IComparer {
2798
2799                 private bool called = false;
2800
2801                 public bool Called {
2802                         get {
2803                                 bool result = called;
2804                                 called = false;
2805                                 return called;
2806                         }
2807                 }
2808
2809                 public int Compare (object x, object y)
2810                 {
2811                         called = true;
2812                         return 0;
2813                 }
2814         }
2815
2816         [Test]
2817         public void BinarySearch1_EmptyList ()
2818         {
2819                 int[] array = new int[0];
2820                 Assert.AreEqual (- 1, Array.BinarySearch (array, 0), "BinarySearch");
2821         }
2822
2823         [Test]
2824         public void BinarySearch2_EmptyList ()
2825         {
2826                 int[] array = new int[0];
2827                 Assert.AreEqual (-1, Array.BinarySearch (array, 0, 0, 0), "BinarySearch");
2828         }
2829
2830         [Test]
2831         public void BinarySearch3_EmptyList ()
2832         {
2833                 Comparer comparer = new Comparer ();
2834                 int[] array = new int[0];
2835                 Assert.AreEqual (-1, Array.BinarySearch (array, 0, comparer), "BinarySearch");
2836                 // bug 77030 - the comparer isn't called for an empty array/list
2837                 Assert.IsTrue (!comparer.Called, "Called");
2838         }
2839
2840         [Test]
2841         public void BinarySearch4_EmptyList ()
2842         {
2843                 Comparer comparer = new Comparer ();
2844                 int[] array = new int[0];
2845                 Assert.AreEqual (-1, Array.BinarySearch (array, 0, 0, comparer), "BinarySearch");
2846                 // bug 77030 - the comparer isn't called for an empty array/list
2847                 Assert.IsTrue (!comparer.Called, "Called");
2848         }
2849
2850         [Test]
2851         [ExpectedException (typeof (ArgumentNullException))]
2852         public void AsReadOnly_NullArray ()
2853         {
2854                 Array.AsReadOnly <int> (null);
2855         }
2856
2857         [Test]
2858         public void ReadOnly_Count ()
2859         {
2860                 Assert.AreEqual (10, Array.AsReadOnly (new int [10]).Count);
2861         }
2862
2863         [Test]
2864         public void ReadOnly_Contains ()
2865         {
2866                 int[] arr = new int [2];
2867                 arr [0] = 3;
2868                 arr [1] = 5;
2869                 IList<int> a = Array.AsReadOnly (arr);
2870
2871                 Assert.IsTrue (a.Contains (3));
2872                 Assert.IsTrue (!a.Contains (6));
2873         }
2874
2875         [Test]
2876         public void ReadOnly_IndexOf ()
2877         {
2878                 int[] arr = new int [2];
2879                 arr [0] = 3;
2880                 arr [1] = 5;
2881                 IList<int> a = Array.AsReadOnly (arr);
2882
2883                 Assert.AreEqual (0, a.IndexOf (3));
2884                 Assert.AreEqual (1, a.IndexOf (5));
2885                 Assert.AreEqual (-1, a.IndexOf (6));
2886         }
2887
2888         [Test]
2889         public void ReadOnly_Indexer ()
2890         {
2891                 int[] arr = new int [2];
2892                 arr [0] = 3;
2893                 arr [1] = 5;
2894                 IList<int> a = Array.AsReadOnly (arr);
2895
2896                 Assert.AreEqual (3, a [0]);
2897                 Assert.AreEqual (5, a [1]);
2898
2899                 /* Check that modifications to the original array are visible */
2900                 arr [0] = 6;
2901                 Assert.AreEqual (6, a [0]);
2902         }
2903
2904         [Test]
2905         public void ReadOnly_Enumerator ()
2906         {
2907                 int[] arr = new int [10];
2908
2909                 for (int i = 0; i < 10; ++i)
2910                         arr [i] = i;
2911
2912                 int sum = 0;
2913                 foreach (int i in Array.AsReadOnly (arr))
2914                         sum += i;
2915
2916                 Assert.AreEqual (45, sum);
2917         }
2918
2919         [Test]
2920         public void ReadOnly_CopyTo ()
2921         {
2922                 int[] arr = new int [2];
2923                 arr [0] = 3;
2924                 arr [1] = 5;
2925                 IList<int> a = Array.AsReadOnly (arr);
2926
2927                 int[] arr2 = new int [3];
2928                 a.CopyTo (arr2, 1);
2929
2930                 Assert.AreEqual (0, arr2 [0]);
2931                 Assert.AreEqual (3, arr2 [1]);
2932                 Assert.AreEqual (5, arr2 [2]);
2933         }
2934
2935         [Test]
2936         public void Resize ()
2937         {
2938                 int [] arr = new int [] { 1, 3, 5 };
2939                 Array.Resize <int> (ref arr, 3);
2940                 Assert.AreEqual (3, arr.Length, "#A1");
2941                 Assert.AreEqual (1, arr [0], "#A2");
2942                 Assert.AreEqual (3, arr [1], "#A3");
2943                 Assert.AreEqual (5, arr [2], "#A4");
2944
2945                 Array.Resize <int> (ref arr, 2);
2946                 Assert.AreEqual (2, arr.Length, "#B1");
2947                 Assert.AreEqual (1, arr [0], "#B2");
2948                 Assert.AreEqual (3, arr [1], "#B3");
2949
2950                 Array.Resize <int> (ref arr, 4);
2951                 Assert.AreEqual (4, arr.Length, "#C1");
2952                 Assert.AreEqual (1, arr [0], "#C2");
2953                 Assert.AreEqual (3, arr [1], "#C3");
2954                 Assert.AreEqual (0, arr [2], "#C4");
2955                 Assert.AreEqual (0, arr [3], "#C5");
2956         }
2957
2958         [Test]
2959         public void Resize_null ()
2960         {
2961                 int [] arr = null;
2962                 Array.Resize (ref arr, 10);
2963                 Assert.AreEqual (arr.Length, 10);
2964         }
2965
2966         [Test]
2967         public void Test_ContainsAndIndexOf_EquatableItem ()
2968         {
2969                 EquatableClass[] list = new EquatableClass[] {new EquatableClass (0), new EquatableClass (1), new EquatableClass (0)};
2970
2971                 Assert.AreEqual (0, Array.IndexOf<EquatableClass> (list, list[0]), "#0");
2972                 Assert.AreEqual (0, Array.IndexOf<EquatableClass> (list, new EquatableClass (0)), "#1");
2973                 Assert.AreEqual (2, Array.LastIndexOf<EquatableClass> (list, list[0]), "#2");
2974                 Assert.AreEqual (2, Array.LastIndexOf<EquatableClass> (list, new EquatableClass (0)), "#3");
2975         }
2976
2977         public class EquatableClass : IEquatable<EquatableClass>
2978         {
2979                 int _x;
2980                 public EquatableClass (int x)
2981                 {
2982                         _x = x;
2983                 }
2984
2985                 public bool Equals (EquatableClass other)
2986                 {
2987                         return this._x == other._x;
2988                 }
2989         }
2990
2991         [Test]
2992         public void AsIList ()
2993         {
2994                 IList<int> arr = new int [10];
2995                 arr [0] = 5;
2996                 Assert.AreEqual (5, arr [0]);
2997
2998                 IList<FooStruct> arr2 = new FooStruct [10];
2999                 FooStruct s = new FooStruct ();
3000                 s.i = 11;
3001                 s.j = 22;
3002                 arr2 [5] = s;
3003                 s = arr2 [5];
3004                 Assert.AreEqual (11, s.i);
3005                 Assert.AreEqual (22, s.j);
3006
3007                 IList<string> arr3 = new string [10];
3008                 arr3 [5] = "ABC";
3009                 Assert.AreEqual ("ABC", arr3 [5]);
3010         }
3011
3012         struct FooStruct {
3013                 public int i, j;
3014         }
3015
3016 #if !TARGET_JVM // BugBUG: T[] is not yet ICollection<T> under TARGET_JVM
3017         [Test]
3018         // From bug #80563
3019         public void ICollectionNull ()
3020         {
3021                 ICollection<object> test;
3022
3023                 test = new List<object>();
3024                 Assert.AreEqual (test.Contains (null), false, "list<o>");
3025
3026                 test = new object[] {};
3027                 Assert.AreEqual (test.Contains (null), false, "empty array");
3028
3029                 test = new object[] {null};
3030                 Assert.AreEqual (test.Contains (null), true, "array with null");
3031
3032                 test = new object[] { 1, null};
3033                 Assert.IsTrue (test.Contains (null), "array with last null");
3034
3035                 test = new List<object>(test);
3036                 Assert.AreEqual (test.Contains (null), true, "List<object> with test");
3037
3038                 test = new object[] {new object()};
3039                 Assert.AreEqual (test.Contains (null), false, "array with object");
3040
3041                 test = new List<object>(test);
3042                 Assert.AreEqual (test.Contains (null), false, "array with test");
3043         }
3044
3045         [Test]
3046         public void IListNull ()
3047         {
3048                 IList<object> test;
3049
3050                 test = new List<object>();
3051                 Assert.AreEqual (-1, test.IndexOf (null), "list<o>");
3052
3053                 test = new object[] {};
3054                 Assert.AreEqual (-1, test.IndexOf (null), "empty array");
3055
3056                 test = new object[] {null};
3057                 Assert.AreEqual (0, test.IndexOf (null), "array with null");
3058
3059                 test = new object[] { 1, null};
3060                 Assert.AreEqual (1, test.IndexOf (null), "array with last null");
3061
3062                 test = new List<object>(test);
3063                 Assert.AreEqual (1, test.IndexOf (null), "List<object> with test");
3064
3065                 test = new object[] {new object()};
3066                 Assert.AreEqual (-1, test.IndexOf (null), "array with object");
3067
3068                 test = new List<object>(test);
3069                 Assert.AreEqual (-1, test.IndexOf (null), "array with test");
3070         }
3071
3072 #endif // TARGET_JVM
3073
3074         #region Bug 80299
3075
3076         enum ByteEnum : byte {}
3077         enum IntEnum : int {}
3078
3079         [Test]
3080         public void TestByteEnumArrayToByteArray ()
3081         {
3082                 ByteEnum[] a = new ByteEnum[] {(ByteEnum) 1, (ByteEnum) 2};
3083                 byte[] b = new byte[a.Length];
3084                 a.CopyTo (b, 0);
3085         }
3086
3087         [Test]
3088         public void TestByteEnumArrayToIntArray ()
3089         {
3090                 ByteEnum[] a = new ByteEnum[] {(ByteEnum) 1, (ByteEnum) 2};
3091                 int[] b = new int[a.Length];
3092                 a.CopyTo (b, 0);
3093         }
3094
3095         [Test]
3096         [ExpectedException (typeof (ArrayTypeMismatchException))]
3097         public void TestIntEnumArrayToByteArray ()
3098         {
3099                 IntEnum[] a = new IntEnum[] {(IntEnum) 1, (IntEnum) 2};
3100                 byte[] b = new byte[a.Length];
3101                 a.CopyTo (b, 0);
3102         }
3103
3104         [Test]
3105         public void TestIntEnumArrayToIntArray ()
3106         {
3107                 IntEnum[] a = new IntEnum[] {(IntEnum) 1, (IntEnum) 2};
3108                 int[] b = new int[a.Length];
3109                 a.CopyTo (b, 0);
3110         }
3111
3112         #endregion
3113
3114         [Test] // bug #322248
3115         public void IEnumerator_Reset ()
3116         {
3117                 int[] array = new int[] { 1, 2, 3};
3118                 IEnumerator<int> e = ((IEnumerable<int>)array).GetEnumerator ();
3119                 Assert.IsTrue (e.MoveNext (), "#A1");
3120                 Assert.AreEqual (1, e.Current, "#A2");
3121                 Assert.IsTrue (e.MoveNext (), "#A3");
3122                 Assert.AreEqual (2, e.Current, "#A4");
3123
3124                 e.Reset ();
3125
3126                 Assert.IsTrue (e.MoveNext (), "#C1");
3127                 Assert.AreEqual (1, e.Current, "#C2");
3128         }
3129
3130         [Test]
3131         public void IEnumerator_Current_Finished ()
3132         {
3133                 int[] array = new int[] { 1, 2, 3 };
3134                 IEnumerator<int> e = ((IEnumerable<int>)array).GetEnumerator ();
3135                 Assert.IsTrue (e.MoveNext (), "#A1");
3136                 Assert.AreEqual (1, e.Current, "#A2");
3137                 Assert.IsTrue (e.MoveNext (), "#A3");
3138                 Assert.AreEqual (2, e.Current, "#A4");
3139                 Assert.IsTrue (e.MoveNext (), "#A5");
3140                 Assert.AreEqual (3, e.Current, "#A6");
3141                 Assert.IsTrue (!e.MoveNext (), "#A6");
3142
3143                 try {
3144                         Assert.Fail ("#B1:" + e.Current);
3145                 } catch (InvalidOperationException ex) {
3146                         // Enumeration already finished
3147                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
3148                         Assert.IsNull (ex.InnerException, "#B3");
3149                         Assert.IsNotNull (ex.Message, "#B4");
3150                 }
3151         }
3152
3153         [Test]
3154         public void IEnumerator_Current_NotStarted ()
3155         {
3156                 int[] array = new int[] { 1, 2, 3 };
3157                 IEnumerator<int> e = ((IEnumerable<int>)array).GetEnumerator ();
3158
3159                 try {
3160                         Assert.Fail ("#A1:" + e.Current);
3161                 } catch (InvalidOperationException ex) {
3162                         // Enumeration has not started. Call MoveNext
3163                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
3164                         Assert.IsNull (ex.InnerException, "#A3");
3165                         Assert.IsNotNull (ex.Message, "#A4");
3166                 }
3167         }
3168
3169         [Test]
3170         public void IEnumerator_Current_Reset ()
3171         {
3172                 int[] array = new int[] { 1, 2, 3 };
3173                 IEnumerator<int> e = ((IEnumerable<int>)array).GetEnumerator ();
3174                 e.MoveNext ();
3175                 e.Reset ();
3176
3177                 try {
3178                         Assert.Fail ("#B1:" + e.Current);
3179                 } catch (InvalidOperationException ex) {
3180                         // Enumeration has not started. Call MoveNext
3181                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
3182                         Assert.IsNull (ex.InnerException, "#B3");
3183                         Assert.IsNotNull (ex.Message, "#B4");
3184                 }
3185         }
3186
3187         public void ICollection_IsReadOnly() {
3188                 ICollection<string> arr = new string [10];
3189
3190                 Assert.IsTrue (arr.IsReadOnly);
3191         }
3192
3193         [Test]
3194         [ExpectedException (typeof (NotSupportedException))]
3195         public void ArrayCreateInstanceOfVoid ()
3196         {
3197                 Array.CreateInstance (typeof (void), 42);
3198         }
3199
3200         class Foo<T> {}
3201
3202         [Test]
3203         [ExpectedException (typeof (NotSupportedException))]
3204         public void ArrayCreateInstanceOfOpenGenericType ()
3205         {
3206                 Array.CreateInstance (typeof (Foo<>), 42);
3207         }
3208
3209         [Test]
3210         [ExpectedException (typeof (IndexOutOfRangeException))]
3211         public void ClearNegativeLength ()
3212         {
3213                 Array.Clear (new int [] { 1, 2 }, 0, -1);
3214         }
3215
3216         [Test]
3217         [ExpectedException (typeof (ArgumentException))]
3218         public void MultiDimension_IList_setItem ()
3219         {
3220                 IList array = new int [1, 1];
3221                 array [0] = 2;
3222         }
3223
3224         [Test]
3225         [ExpectedException (typeof (ArgumentException))]
3226         public void MultiDimension_IList_getItem ()
3227         {
3228                 IList array = new int [1, 1];
3229                 int a = (int) array [0];
3230         }
3231
3232         [Test]
3233         public void SetValue_Nullable () {
3234                 Array array = Array.CreateInstance (typeof (int?), 7);
3235
3236                 object o = 42;
3237
3238                 array.SetValue (o, 0);
3239                 Assert.AreEqual (42, array.GetValue (0));
3240
3241                 array.SetValue (null, 0);
3242                 Assert.AreEqual (null, array.GetValue (0));
3243         }
3244
3245         [Test]
3246         public void SortNullsWithGenericVersion ()
3247         {
3248             string[] s1 = new string[6]{
3249                 "J",
3250                 "M",
3251                  null,
3252                 "P",
3253                 "T",
3254                 "A"};
3255
3256             string[] s2 = new string[]{null,
3257                 "A",
3258                 "J",
3259                 "M",
3260                 "P",
3261                 "T"};
3262
3263             Array.Sort<string> (s1);
3264             for (int i = 0; i < 6; i++) {
3265                     Assert.AreEqual (s1[i], s2[i], "At:" + i);
3266             }
3267         }
3268
3269         //
3270         // This is a test case for the case that was broken by the code contributed
3271         // for bug  #351638.
3272         //
3273         // This tests the fix for: #622101
3274         //
3275         [Test]
3276         public void SortActuallyWorks ()
3277         {
3278                 string[] data = new string[9]{"Foo", "Bar", "Dingus", null, "Dingu4", "123", "Iam", null, "NotNull"};
3279                 IComparer comparer = new NullAtEndComparer ();
3280                 Array.Sort (data, comparer);
3281
3282                 Assert.AreEqual (data [7], null);
3283                 Assert.AreNotEqual (data [0], null);
3284         }
3285
3286         class NullAtEndComparer : IComparer {
3287                 public int Compare(object x, object y)
3288                 {
3289                         if (x == null) return 1;
3290                         if (y == null) return -1;
3291                         return ((string)x).CompareTo((string)y);
3292                 }
3293         }
3294
3295 #if NET_4_0
3296         [Test]
3297         [ExpectedException (typeof (ArgumentException))]
3298         public void CompareToWithJaggedArray () {
3299                 IStructuralComparable a = new int[][] { new int [] { 1,2 }, new int [] { 3,4 }};
3300                 IStructuralComparable b = new int[][] { new int [] { 1,2 }, new int [] { 3,4 }};
3301                 a.CompareTo (b, Comparer<object>.Default);
3302         }
3303
3304         [Test]
3305         [ExpectedException (typeof (ArgumentException))]
3306         public void CompareToWithArrayOfTheWrongKind () {
3307                 IStructuralComparable a = new int[] { 1, 2 };
3308                 IStructuralComparable b = new double[] { 1, 2 };
3309                 a.CompareTo (b, Comparer<object>.Default);
3310         }
3311
3312         [Test]
3313         [ExpectedException (typeof (ArgumentException))]
3314         public void CompareToWithNonArrayType () {
3315                 IStructuralComparable a = new int[] { 1, 2 };
3316                 a.CompareTo (99, Comparer<object>.Default);
3317         }
3318
3319         [Test]
3320         [ExpectedException (typeof (ArgumentException))]
3321         public void CompareToWithNonArrayOfDifferentSize () {
3322                 IStructuralComparable a = new int[] { 1, 2 };
3323                 IStructuralComparable b = new int[] { 1, 2, 3 };
3324                 a.CompareTo (b, Comparer<object>.Default);
3325         }
3326
3327         [Test]
3328         [ExpectedException (typeof (ArgumentException))]
3329         public void CompareToWithMultiDimArray1 () {
3330                 IStructuralComparable a = new int [2,2] { {10, 10 }, { 10, 10 } };
3331                 IStructuralComparable b = new int [2,2] { {10, 10 }, { 10, 10 } };
3332                 a.CompareTo (b, Comparer<object>.Default);
3333         }
3334
3335         [Test]
3336         [ExpectedException (typeof (ArgumentException))]
3337         public void CompareToWithMultiDimArray2 () {
3338                 IStructuralComparable a = new int [2] { 10, 10 };
3339                 IStructuralComparable b = new int [2,2] { {10, 10 }, { 10, 10 } };
3340                 a.CompareTo (b, Comparer<object>.Default);
3341         }
3342
3343         [Test]
3344         [ExpectedException (typeof (ArgumentException))]
3345         public void CompareToWithMultiDimArray3 () {
3346                 IStructuralComparable a = new int [4] { 10, 10, 10, 10 };
3347                 IStructuralComparable b = new int [2,2] { {10, 10 }, { 10, 10 } };
3348                 a.CompareTo (b, Comparer<object>.Default);
3349         }
3350
3351         [Test]
3352         [ExpectedException (typeof (IndexOutOfRangeException))]
3353         public void CompareToWithBoundedArray1 () {
3354                 IStructuralComparable a = new int [2] { 10, 10 };
3355                 Array ab = Array.CreateInstance (typeof (int), new int[] { 2 }, new int [] { 5 });
3356                 IStructuralComparable b = ab;
3357                 ab.SetValue (10, 5);
3358                 ab.SetValue (10, 6);
3359
3360                 a.CompareTo (b, Comparer<object>.Default);
3361         }
3362
3363         [Test]
3364         [ExpectedException (typeof (IndexOutOfRangeException))]
3365         public void CompareToWithBoundedArray2 () {
3366                 IStructuralComparable a = new int [2] { 10, 10 };
3367                 Array ab = Array.CreateInstance (typeof (int), new int[] { 2 }, new int [] { 5 });
3368                 IStructuralComparable b = ab;
3369                 ab.SetValue (10, 5);
3370                 ab.SetValue (10, 6);
3371
3372                 //Yes, CompareTo simply doesn't work with bounded arrays!
3373                 b.CompareTo (b, Comparer<object>.Default);
3374         }
3375
3376         [Test]
3377         [ExpectedException (typeof (NullReferenceException))]
3378         public void CompareToWithNullComparer () {
3379                 IStructuralComparable a = new int[] { 1, 2 };
3380                 IStructuralComparable b = new int[] { 1, 2 };
3381                 a.CompareTo (b, null);
3382         }
3383
3384         [Test]
3385         public void CompareToWithNullArray () {
3386                 IStructuralComparable a = new int[] { 1, 2 };
3387                 Assert.AreEqual (1, a.CompareTo (null, Comparer<object>.Default));
3388         }
3389
3390         [Test]
3391         public void CompareToWithGoodArrays () {
3392                 IStructuralComparable a = new int[] { 10, 20 };
3393                 Assert.AreEqual (0, a.CompareTo (a, Comparer<object>.Default));
3394                 Assert.AreEqual (0, a.CompareTo (new int [] { 10, 20 }, Comparer<object>.Default));
3395                 Assert.AreEqual (-1, a.CompareTo (new int [] { 11, 20 }, Comparer<object>.Default));
3396                 Assert.AreEqual (-1, a.CompareTo (new int [] { 10, 21 }, Comparer<object>.Default));
3397                 Assert.AreEqual (1, a.CompareTo (new int [] { 9, 20 }, Comparer<object>.Default));
3398                 Assert.AreEqual (1, a.CompareTo (new int [] { 10, 19 }, Comparer<object>.Default));
3399         }
3400
3401         [Test]
3402         public void IStructuralEquatable_Equals ()
3403         {
3404                 IStructuralEquatable array = new int[] {1, 2, 3};
3405                 IStructuralEquatable array2 = new int[] {1, 2, 3};
3406                 Assert.AreEqual (false, array.Equals (null, null));
3407                 Assert.AreEqual (true, array.Equals (array, null));
3408                 Assert.AreEqual (true, array.Equals (array2, EqualityComparer<int>.Default));
3409         }
3410
3411         [Test]
3412         [ExpectedException (typeof (NullReferenceException))]
3413         public void IStructuralEquatable_Equals_NoComparer ()
3414         {
3415                 IStructuralEquatable array = new int[] {1, 2, 3};
3416                 IStructuralComparable array2 = new int[] {1, 2, 3};
3417                 array.Equals (array2, null);
3418         }
3419
3420         [Test]
3421         [ExpectedException (typeof (ArgumentException))]
3422         public void IStructuralEquatable_Equals_ComparerThrows ()
3423         {
3424                 IStructuralEquatable array = new int[] {1, 2, 3};
3425                 IStructuralComparable array2 = new int[] {1, 2, 3};
3426                 array.Equals (array2, EqualityComparer<long>.Default);
3427         }
3428
3429         [Test]
3430         [ExpectedException (typeof (ArgumentNullException))]
3431         public void IStructuralEquatable_GetHashCode_NullComparer ()
3432         {
3433                 IStructuralEquatable a = new int[] { 1, 2 };
3434                 a.GetHashCode (null);
3435         }
3436
3437         class TestComparer_GetHashCode : IEqualityComparer
3438         {
3439                 public int Counter;
3440
3441                 bool IEqualityComparer.Equals (object x, object y)
3442                 {
3443                         throw new NotImplementedException ();
3444                 }
3445
3446                 public int GetHashCode (object obj)
3447                 {
3448                         return Counter++;
3449                 }
3450         }
3451
3452         [Test]
3453         public void IStructuralEquatable_GetHashCode ()
3454         {
3455                 IStructuralEquatable a = new int[] { 1, 2, 9 };
3456
3457                 var c = new TestComparer_GetHashCode ();
3458                 a.GetHashCode (c);
3459                 Assert.AreEqual (3, c.Counter);
3460         }
3461
3462 #endif
3463
3464 }
3465 }