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

   1 //
   2 // MonoTests.System.ArraySortArgChecks
   3 //
   4 // Authors:
   5 //      Juraj Skripsky  (js@hotfeet.ch)
   6 //
   7 // Copyright (C) 2009 Juraj Skripsky (js@hotfeet.ch)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using NUnit.Framework;
  30 using System;
  31 using System.Collections;
  32 using System.Collections.Generic;
  33
  34
  35 namespace MonoTests.System {
  36         class SomeIncomparable {}
  37         class SomeComparable : IComparable {
  38                 int IComparable.CompareTo (object other) {
  39                         return 0;
  40                 }
  41         }
  42
  43         [TestFixture]
  44         public class ArraySortArgChecks {
  45
  46                 [Test]
  47                 public void Check_ArgumentNullException() {
  48                         try {
  49                                 Array.Sort (null);
  50                                 Assert.Fail ("#1");
  51                         } catch (ArgumentNullException) {}
  52
  53                         try {
  54                                 Array.Sort (null, (Array)null);
  55                                 Assert.Fail ("#2");
  56                         } catch (ArgumentNullException) {}
  57
  58                         try {
  59                                 Array.Sort (null, (IComparer)null);
  60                                 Assert.Fail ("#3");
  61                         } catch (ArgumentNullException) {}
  62
  63                         try {
  64                                 Array.Sort (null, 0, 0);
  65                                 Assert.Fail ("#4");
  66                         } catch (ArgumentNullException) {}
  67
  68                         try {
  69                                 Array.Sort (null, null, null);
  70                                 Assert.Fail ("#5");
  71                         } catch (ArgumentNullException) {}
  72
  73                         try {
  74                                 Array.Sort (null, null, 0, 0);
  75                                 Assert.Fail ("#6");
  76                         } catch (ArgumentNullException) {}
  77
  78                         try {
  79                                 Array.Sort (null, 0, 0, null);
  80                                 Assert.Fail ("#7");
  81                         } catch (ArgumentNullException) {}
  82
  83                         try {
  84                                 Array.Sort (null, null, 0, 0, null);
  85                                 Assert.Fail ("#8");
  86                         } catch (ArgumentNullException) {}
  87
  88                         try {
  89                                 Array.Sort<object> (null);
  90                                 Assert.Fail ("#9");
  91                         } catch (ArgumentNullException) {}
  92
  93                         try {
  94                                 Array.Sort<object, object> (null, null);
  95                                 Assert.Fail ("#10");
  96                         } catch (ArgumentNullException) {}
  97
  98                         try {
  99                                 Array.Sort<object> (null, (IComparer<object>)null);
 100                                 Assert.Fail ("#11");
 101                         } catch (ArgumentNullException) {}
 102
 103                         try {
 104                                 Array.Sort<object, object> (null, null, null);
 105                                 Assert.Fail ("#12");
 106                         } catch (ArgumentNullException) {}
 107
 108                         try {
 109                                 Array.Sort<object> (null, 0, 0);
 110                                 Assert.Fail ("#13");
 111                         } catch (ArgumentNullException) {}
 112
 113                         try {
 114                                 Array.Sort<object, object> (null, null, 0, 0);
 115                                 Assert.Fail ("#14");
 116                         } catch (ArgumentNullException) {}
 117
 118                         try {
 119                                 Array.Sort<object> (null, 0, 0, null);
 120                                 Assert.Fail ("#15");
 121                         } catch (ArgumentNullException) {}
 122
 123                         try {
 124                                 Array.Sort<object, object> (null, null, 0, 0, null);
 125                                 Assert.Fail ("#16");
 126                         } catch (ArgumentNullException) {}
 127
 128                         try {
 129                                 Array.Sort<object> (null, new Comparison<object>(ObjComparison));
 130                                 Assert.Fail ("#17");
 131                         } catch (ArgumentNullException) {}
 132                 }
 133
 134                 public static int ObjComparison (object o1, object o2) {
 135                         return 0;
 136                 }
 137
 138
 139                 [Test]
 140                 public void Check_ArgumentException() {
 141                         object[] arr = new object[] {1, 2, 3, 4, 5};
 142
 143                         try {
 144                                 Array.Sort (arr, 1, 5);
 145                                 Assert.Fail ("#1");
 146                         } catch (ArgumentException) {}
 147
 148                         try {
 149                                 Array.Sort (arr, null, 1, 5);
 150                                 Assert.Fail ("#2");
 151                         } catch (ArgumentException) {}
 152
 153                         try {
 154                                 Array.Sort (arr, 1, 5, null);
 155                                 Assert.Fail ("#3");
 156                         } catch (ArgumentException) {}
 157
 158                         try {
 159                                 Array.Sort (arr, null, 1, 5, null);
 160                                 Assert.Fail ("#4");
 161                         } catch (ArgumentException) {}
 162
 163                         try {
 164                                 Array.Sort<object> (arr, 1, 5);
 165                                 Assert.Fail ("#5");
 166                         } catch (ArgumentException) {}
 167
 168                         try {
 169                                 Array.Sort<object, object> (arr, null, 1, 5);
 170                                 Assert.Fail ("#6");
 171                         } catch (ArgumentException) {}
 172
 173                         try {
 174                                 Array.Sort<object> (arr, 1, 5, null);
 175                                 Assert.Fail ("#7");
 176                         } catch (ArgumentException) {}
 177
 178                         try {
 179                                 Array.Sort<object, object> (arr, null, 1, 5, null);
 180                                 Assert.Fail ("#8");
 181                         } catch (ArgumentException) {}
 182                 }
 183
 184                 [Test]
 185                 public void Check_ArgumentOurOfRangeException() {
 186                         object[] arr = new object[] {1, 2, 3, 4, 5};
 187                         try {
 188                                 Array.Sort (arr, -1, 1);
 189                                 Assert.Fail ("#1");
 190                         } catch (ArgumentOutOfRangeException) {}
 191
 192                         try {
 193                                 Array.Sort (arr, null, -1, 1);
 194                                 Assert.Fail ("#2");
 195                         } catch (ArgumentOutOfRangeException) {}
 196
 197                         try {
 198                                 Array.Sort (arr, -1, 1, null);
 199                                 Assert.Fail ("#3");
 200                         } catch (ArgumentOutOfRangeException) {}
 201
 202                         try {
 203                                 Array.Sort (arr, null, -1, 1, null);
 204                                 Assert.Fail ("#4");
 205                         } catch (ArgumentOutOfRangeException) {}
 206
 207                         try {
 208                                 Array.Sort (arr, 0, -1);
 209                                 Assert.Fail ("#1");
 210                         } catch (ArgumentOutOfRangeException) {}
 211
 212                         try {
 213                                 Array.Sort (arr, null, 0, -1);
 214                                 Assert.Fail ("#2");
 215                         } catch (ArgumentOutOfRangeException) {}
 216
 217                         try {
 218                                 Array.Sort (arr, 0, -1, null);
 219                                 Assert.Fail ("#3");
 220                         } catch (ArgumentOutOfRangeException) {}
 221
 222                         try {
 223                                 Array.Sort (arr, null, 0, -1, null);
 224                                 Assert.Fail ("#4");
 225                         } catch (ArgumentOutOfRangeException) {}
 226
 227                         try {
 228                                 Array.Sort<object> (arr, -1, 1);
 229                                 Assert.Fail ("#5");
 230                         } catch (ArgumentOutOfRangeException) {}
 231
 232                         try {
 233                                 Array.Sort<object, object> (arr, null, -1, 1);
 234                                 Assert.Fail ("#6");
 235                         } catch (ArgumentOutOfRangeException) {}
 236
 237                         try {
 238                                 Array.Sort<object> (arr, -1, 1, null);
 239                                 Assert.Fail ("#7");
 240                         } catch (ArgumentOutOfRangeException) {}
 241
 242                         try {
 243                                 Array.Sort<object, object> (arr, null, -1, 1, null);
 244                                 Assert.Fail ("#8");
 245                         } catch (ArgumentOutOfRangeException) {}
 246
 247                         try {
 248                                 Array.Sort<object> (arr, 0, -1);
 249                                 Assert.Fail ("#5");
 250                         } catch (ArgumentOutOfRangeException) {}
 251
 252                         try {
 253                                 Array.Sort<object, object> (arr, null, 0, -1);
 254                                 Assert.Fail ("#6");
 255                         } catch (ArgumentOutOfRangeException) {}
 256
 257                         try {
 258                                 Array.Sort<object> (arr, 0, -1, null);
 259                                 Assert.Fail ("#7");
 260                         } catch (ArgumentOutOfRangeException) {}
 261
 262                         try {
 263                                 Array.Sort<object, object> (arr, null, 0, -1, null);
 264                                 Assert.Fail ("#8");
 265                         } catch (ArgumentOutOfRangeException) {}
 266                 }
 267
 268                 [Test]
 269                 public void Check_RankException() {
 270                         object[,] arr = new object[2,2];
 271
 272                         try {
 273                                 Array.Sort (arr);
 274                                 Assert.Fail ("#1");
 275                         } catch (RankException) {}
 276
 277                         try {
 278                                 Array.Sort (arr, (Array)null);
 279                                 Assert.Fail ("#2");
 280                         } catch (RankException) {}
 281
 282                         try {
 283                                 Array.Sort (arr, (IComparer)null);
 284                                 Assert.Fail ("#3");
 285                         } catch (RankException) {}
 286
 287                         try {
 288                                 Array.Sort (arr, 0, 0);
 289                                 Assert.Fail ("#4");
 290                         } catch (RankException) {}
 291
 292                         try {
 293                                 Array.Sort (arr, null, null);
 294                                 Assert.Fail ("#5");
 295                         } catch (RankException) {}
 296
 297                         try {
 298                                 Array.Sort (arr, null, 0, 0);
 299                                 Assert.Fail ("#6");
 300                         } catch (RankException) {}
 301
 302                         try {
 303                                 Array.Sort (arr, 0, 0, null);
 304                                 Assert.Fail ("#7");
 305                         } catch (RankException) {}
 306
 307                         try {
 308                                 Array.Sort (arr, null, 0, 0, null);
 309                                 Assert.Fail ("#8");
 310                         } catch (RankException) {}
 311                 }
 312
 313                 [Test]
 314                 public void Check_NoInvalidOperationException ()
 315                 {
 316                         Array arr = new object[] {new SomeComparable (), new SomeIncomparable (), new SomeComparable ()};
 317
 318                         Array.Sort (arr);
 319
 320                         Array.Sort (arr, (Array)null);
 321
 322                         Array.Sort (arr, (IComparer)null);
 323
 324                         Array.Sort (arr, 0, 3);
 325
 326                         Array.Sort (arr, null, null);
 327
 328                         Array.Sort (arr, null, 0, 3);
 329
 330                         Array.Sort (arr, 0, 3, null);
 331
 332                         Array.Sort (arr, null, 0, 3, null);
 333                 }
 334
 335                 [Test]
 336                 public void Check_NoInvalidOperationException_Generic ()
 337                 {
 338                         object[] arr = new object[] {new SomeComparable (), new SomeIncomparable (), new SomeComparable ()};
 339
 340                         Array.Sort<object> (arr);
 341
 342                         Array.Sort<object, object> (arr, null);
 343
 344                         Array.Sort<object> (arr, (IComparer<object>)null);
 345
 346                         Array.Sort<object, object> (arr, null, null);
 347
 348                         Array.Sort<object> (arr, 0, 3);
 349
 350                         Array.Sort<object, object> (arr, null, 0, 3);
 351
 352                         Array.Sort<object> (arr, 0, 3, null);
 353
 354                         Array.Sort<object, object> (arr, null, 0, 3, null);
 355                 }
 356         }
 357 }