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