mcs/class/corlib/Test/System.Collections.Generic/ListTest.cs

   1 //
   2 // MonoTests.System.Collections.Generic.Test.DictionaryTest
   3 //
   4 // Authors:
   5 //      David Waite (mass@akuma.org)
   6 //
   7 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
   8 // Copyright (C) 2005 David Waite (mass@akuma.org)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 #if NET_2_0
  31
  32 using System;
  33 using System.Collections;
  34 using System.Collections.Generic;
  35 using System.Collections.ObjectModel;
  36 using System.Text;
  37 using NUnit.Framework;
  38
  39 namespace MonoTests.System.Collections.Generic {
  40
  41         [TestFixture]
  42         public class ListTest
  43         {
  44
  45                 int [] _list1_contents;
  46                 List <int> _list1;
  47
  48                 [SetUp]
  49                 public void SetUp ()
  50                 {
  51                         // FIXME arrays currently do not support generic collection
  52                         // interfaces
  53                         _list1_contents = new int [] { 55, 50, 22, 80, 56, 52, 40, 63 };
  54                         // _list1 = new List <int> (_list1_contents);
  55
  56                         _list1 = new List <int> (8);
  57                         foreach (int i in _list1_contents)
  58                                 _list1.Add (i);
  59                 }
  60
  61                 [Test]  // This was for bug #74980
  62                 public void InsertTest ()
  63                 {
  64                         List <string> test = new List <string> ();
  65                         test.Insert (0, "a");
  66                         test.Insert (0, "b");
  67                         test.Insert (1, "c");
  68
  69                         Assert.AreEqual (3, test.Count);
  70                         Assert.AreEqual ("b", test [0]);
  71                         Assert.AreEqual ("c", test [1]);
  72                         Assert.AreEqual ("a", test [2]);
  73                 }
  74
  75                 [Test]
  76                 public void InsertRangeTest ()
  77                 {
  78                         int count = _list1.Count;
  79                         // FIXME arrays currently do not support generic collection
  80                         // interfaces
  81                         int [] items = {1, 2, 3};
  82                         // List <int> newRange = new List <int> (items);
  83                         List <int> newRange = new List <int> (3);
  84                         foreach (int i in items)
  85                                    newRange.Add (i);
  86                         _list1.InsertRange (1, newRange);
  87                         Assert.AreEqual (count + 3, _list1.Count);
  88                         Assert.AreEqual (55, _list1 [0]);
  89                         Assert.AreEqual (1, _list1 [1]);
  90                         Assert.AreEqual (2, _list1 [2]);
  91                         Assert.AreEqual (3, _list1 [3]);
  92                         Assert.AreEqual (50, _list1 [4]);
  93                 }
  94
  95                 [Test, ExpectedException (typeof (ArgumentNullException))]
  96                 public void InsertRangeNullTest ()
  97                 {
  98                         IEnumerable <int> n = null;
  99                         _list1.InsertRange (0, n);
 100                 }
 101
 102                 [Test]
 103                 public void IndexOfTest ()
 104                 {
 105                         List <int> l = new List <int> ();
 106
 107                         l.Add (100);
 108                         l.Add (200);
 109
 110                         Assert.AreEqual (1, l.IndexOf (200), "Could not find value");
 111                 }
 112
 113                 [Test, ExpectedException (typeof (ArgumentException))]
 114                 public void IndexOfOutOfRangeTest ()
 115                 {
 116                         List <int> l = new List <int> (4);
 117                         l.IndexOf (0, 0, 4);
 118                 }
 119
 120                 [Test]
 121                 public void GetRangeTest ()
 122                 {
 123                         List <int> r = _list1.GetRange (2, 4);
 124                         Assert.AreEqual (4, r.Count);
 125                         Assert.AreEqual (22, r [0]);
 126                         Assert.AreEqual (80, r [1]);
 127                         Assert.AreEqual (56, r [2]);
 128                         Assert.AreEqual (52, r [3]);
 129                 }
 130
 131                 [Test]
 132                 public void EnumeratorTest ()
 133                 {
 134                         List <int>.Enumerator e = _list1.GetEnumerator ();
 135                         for (int i = 0; i < _list1_contents.Length; i++)
 136                         {
 137                                 Assert.IsTrue (e.MoveNext ());
 138                                 Assert.AreEqual (_list1_contents [i], e.Current);
 139                         }
 140                         Assert.IsFalse (e.MoveNext ());
 141                 }
 142
 143                 [Test]
 144                 public void ConstructWithSizeTest ()
 145                 {
 146                         List <object> l_1 = new List <object> (1);
 147                         List <object> l_2 = new List <object> (50);
 148                         List <object> l_3 = new List <object> (0);
 149
 150                         Assert.AreEqual (1, l_1.Capacity);
 151                         Assert.AreEqual (50, l_2.Capacity);
 152                         Assert.AreEqual (0, l_3.Capacity);
 153                 }
 154
 155                 [Test, ExpectedException (typeof (ArgumentOutOfRangeException))]
 156                 public void ConstructWithInvalidSizeTest ()
 157                 {
 158                         List <int> l = new List <int> (-1);
 159                 }
 160
 161                 [Test]
 162                 public void ConstructWithCollectionTest ()
 163                 {
 164                         List <int> l1 = new List <int> (_list1);
 165                         Assert.AreEqual (_list1.Count, l1.Count);
 166                         Assert.AreEqual (l1.Count, l1.Capacity);
 167                         for (int i = 0; i < l1.Count; i++)
 168                                 Assert.AreEqual (_list1 [i], l1 [i]);
 169                 }
 170
 171                 [Test, ExpectedException (typeof (ArgumentNullException))]
 172                 public void ConstructWithInvalidCollectionTest ()
 173                 {
 174                         List <int> n = null;
 175                         List <int> l1 = new List <int> (n);
 176                 }
 177
 178                 [Test]
 179                 public void AddTest ()
 180                 {
 181                         int count = _list1.Count;
 182                         _list1.Add (-1);
 183                         Assert.AreEqual (count + 1, _list1.Count);
 184                         Assert.AreEqual (-1, _list1 [_list1.Count - 1]);
 185                 }
 186
 187                 [Test]
 188                 public void AddRangeTest ()
 189                 {
 190                         int count = _list1.Count;
 191                         // FIXME arrays currently do not support generic collection
 192                         // interfaces
 193                         int [] range = { -1, -2, -3 };
 194                         List <int> tmp = new List <int> (3);
 195                         foreach (int i in range)
 196                                 tmp.Add (i);
 197                         // _list1.AddRange (range);
 198                         _list1.AddRange (tmp);
 199
 200                         Assert.AreEqual (count + 3, _list1.Count);
 201                         Assert.AreEqual (-1, _list1 [_list1.Count - 3]);
 202                         Assert.AreEqual (-2, _list1 [_list1.Count - 2]);
 203                         Assert.AreEqual (-3, _list1 [_list1.Count - 1]);
 204                 }
 205
 206                 [Test, ExpectedException (typeof (ArgumentNullException))]
 207                 public void AddNullRangeTest ()
 208                 {
 209                         int [] n = null;
 210                         _list1.AddRange (n);
 211                 }
 212
 213                 [Test]
 214                 public void AsReadOnlyTest ()
 215                 {
 216                         // FIXME: workaround for lack of ReadOnlyCollection <T>
 217                         ReadOnlyCollection <int> l = _list1.AsReadOnly ();
 218                         Assert.IsTrue (l.IsReadOnly);
 219                         Assert.AreEqual (_list1.Count, l.Count);
 220                         try
 221                         {
 222                                 l.Add (4);
 223                                 Assert.Fail ("must fail to modify read-only collection");
 224                         }
 225                         catch (NotSupportedException)
 226                         { }
 227                 }
 228
 229                 [Test]
 230                 public void BinarySearchTest ()
 231                 {
 232                         List <int> l = new List <int> (_list1);
 233                         l.Sort ();
 234                         Assert.AreEqual (0, l.BinarySearch (22));
 235                         Assert.AreEqual (-2, l.BinarySearch (23));
 236                         Assert.AreEqual (- (l.Count + 1), l.BinarySearch (int.MaxValue));
 237                 }
 238
 239                 [Test]
 240                 public void SortTest ()
 241                 {
 242                         List <int> l = new List <int> (_list1);
 243                         l.Sort ();
 244                         Assert.AreEqual (_list1.Count, l.Count);
 245                         Assert.AreEqual (22, l [0]);
 246                         int minimum = 22;
 247                         foreach (int i in l)
 248                         {
 249                                 Assert.IsTrue (minimum <= i);
 250                                 minimum = i;
 251                         }
 252                 }
 253
 254                 [Test]
 255                 public void ClearTest ()
 256                 {
 257                         int capacity = _list1.Capacity;
 258                         _list1.Clear ();
 259                         Assert.AreEqual (0, _list1.Count);
 260                         Assert.AreEqual (capacity, _list1.Capacity);
 261                 }
 262
 263                 [Test]
 264                 public void ContainsTest ()
 265                 {
 266                         Assert.IsTrue (_list1.Contains (22));
 267                         Assert.IsFalse (_list1.Contains (23));
 268                 }
 269
 270                 private string StringConvert (int i)
 271                 {
 272                         return i.ToString ();
 273                 }
 274
 275                 [Test]
 276                 public void ConvertAllTest ()
 277                 {
 278                         List <string> s = _list1.ConvertAll ( (Converter <int, string>)StringConvert);
 279                         Assert.AreEqual (_list1.Count, s.Count);
 280                         Assert.AreEqual ("55", s [0]);
 281                 }
 282
 283                 [Test]
 284                 public void CopyToTest ()
 285                 {
 286                         int [] a = new int [2];
 287                         _list1.CopyTo (1, a, 0, 2);
 288                         Assert.AreEqual (50, a [0]);
 289                         Assert.AreEqual (22, a [1]);
 290
 291                         int [] b = new int [_list1.Count + 1];
 292                         b [_list1.Count] = 555;
 293                         _list1.CopyTo (b);
 294                         Assert.AreEqual (55, b [0]);
 295                         Assert.AreEqual (555, b [_list1.Count]);
 296
 297                         b [0] = 888;
 298                         _list1.CopyTo (b, 1);
 299                         Assert.AreEqual (888, b [0]);
 300                         Assert.AreEqual (55, b [1]);
 301                 }
 302
 303                 [Test, ExpectedException (typeof (ArgumentNullException))]
 304                 public void CopyToNullTest ()
 305                 {
 306                         int [] a = null;
 307                         _list1.CopyTo (0, a, 0, 0);
 308                 }
 309
 310                 static bool FindMultipleOfThree (int i)
 311                 {
 312                         return (i % 3) == 0;
 313                 }
 314
 315                 static bool FindMultipleOfFour (int i)
 316                 {
 317                         return (i % 4) == 0;
 318                 }
 319
 320                 static bool FindMultipleOfTwelve (int i)
 321                 {
 322                         return (i % 12) == 0;
 323                 }
 324
 325                 [Test]
 326                 public void FindTest ()
 327                 {
 328                         int i = _list1.Find (FindMultipleOfThree);
 329                         Assert.AreEqual (63, i);
 330
 331                         i = _list1.Find (FindMultipleOfTwelve);
 332                         Assert.AreEqual (default (int), i);
 333                 }
 334
 335                 [Test, ExpectedException (typeof (ArgumentNullException))]
 336                 public void FindNullTest ()
 337                 {
 338                         int i = _list1.Find (null);
 339                 }
 340
 341                 [Test]
 342                 public void FindAllTest ()
 343                 {
 344                         List <int> findings = _list1.FindAll (FindMultipleOfFour);
 345                         Assert.AreEqual (4, findings.Count);
 346                         Assert.AreEqual (80, findings [0]);
 347                         Assert.AreEqual (56, findings [1]);
 348                         Assert.AreEqual (52, findings [2]);
 349                         Assert.AreEqual (40, findings [3]);
 350
 351                         findings = _list1.FindAll (FindMultipleOfTwelve);
 352                         Assert.IsNotNull (findings);
 353                         Assert.AreEqual (0, findings.Count);
 354                 }
 355
 356                 [Test, ExpectedException (typeof (ArgumentNullException))]
 357                 public void FindAllNullTest ()
 358                 {
 359                         List <int> findings = _list1.FindAll (null);
 360                 }
 361
 362                 [Test]
 363                 public void FindIndexTest ()
 364                 {
 365                         int i = _list1.FindIndex (FindMultipleOfThree);
 366                         Assert.AreEqual (7, i);
 367
 368                         i = _list1.FindIndex (FindMultipleOfTwelve);
 369                         Assert.AreEqual (-1, i);
 370                 }
 371
 372                 [Test, ExpectedException (typeof (ArgumentNullException))]
 373                 public void FindIndexNullTest ()
 374                 {
 375                         int i = _list1.FindIndex (null);
 376                 }
 377
 378                 [Test]
 379                 public void FindLastTest ()
 380                 {
 381                         int i = _list1.FindLast (FindMultipleOfFour);
 382                         Assert.AreEqual (40, i);
 383
 384                         i = _list1.FindLast (FindMultipleOfTwelve);
 385                         Assert.AreEqual (default (int), i);
 386                 }
 387
 388                 [Test, ExpectedException (typeof (ArgumentNullException))]
 389                 public void FindLastNullTest ()
 390                 {
 391                         int i = _list1.FindLast (null);
 392                 }
 393
 394                 // FIXME currently generates Invalid IL Code error
 395                 /*
 396                 [Test]
 397                 public void ForEachTest ()
 398                 {
 399                         int i = 0;
 400                         _list1.ForEach (delegate (int j) { i += j; });
 401
 402                         Assert.AreEqual (418, i);
 403                 }
 404                 */
 405                 [Test]
 406                 public void FindLastIndexTest ()
 407                 {
 408                         int i = _list1.FindLastIndex (FindMultipleOfFour);
 409                         Assert.AreEqual (6, i);
 410
 411                         i = _list1.FindLastIndex (5, FindMultipleOfFour);
 412                         Assert.AreEqual (5, i);
 413
 414                         i = _list1.FindIndex (FindMultipleOfTwelve);
 415                         Assert.AreEqual (-1, i);
 416                 }
 417
 418                 [Test, ExpectedException (typeof (ArgumentNullException))]
 419                 public void FindLastIndexNullTest ()
 420                 {
 421                         int i = _list1.FindLastIndex (null);
 422                 }
 423
 424                 [Test]
 425                 public void RemoveTest ()
 426                 {
 427                         int count = _list1.Count;
 428                         bool result = _list1.Remove (22);
 429                         Assert.IsTrue (result);
 430                         Assert.AreEqual (count - 1, _list1.Count);
 431
 432                         Assert.AreEqual (-1, _list1.IndexOf (22));
 433
 434                         result = _list1.Remove (0);
 435                         Assert.IsFalse (result);
 436                 }
 437
 438                 [Test]
 439                 public void RemoveAllTest ()
 440                 {
 441                         int count = _list1.Count;
 442                         int removedCount = _list1.RemoveAll (FindMultipleOfFour);
 443                         Assert.AreEqual (4, removedCount);
 444                         Assert.AreEqual (count - 4, _list1.Count);
 445
 446                         removedCount = _list1.RemoveAll (FindMultipleOfTwelve);
 447                         Assert.AreEqual (0, removedCount);
 448                         Assert.AreEqual (count - 4, _list1.Count);
 449                 }
 450
 451                 [Test]
 452                 public void RemoveAtTest ()
 453                 {
 454                         int count = _list1.Count;
 455                         _list1.RemoveAt (0);
 456                         Assert.AreEqual (count - 1, _list1.Count);
 457                         Assert.AreEqual (50, _list1 [0]);
 458                 }
 459
 460                 [Test, ExpectedException (typeof (ArgumentOutOfRangeException))]
 461                 public void RemoveOutOfRangeTest ()
 462                 {
 463                         _list1.RemoveAt (_list1.Count);
 464                 }
 465
 466                 [Test]
 467                 public void RemoveRangeTest ()
 468                 {
 469                         int count = _list1.Count;
 470                         _list1.RemoveRange (1, 2);
 471                         Assert.AreEqual (count - 2, _list1.Count);
 472                         Assert.AreEqual (55, _list1 [0]);
 473                         Assert.AreEqual (80, _list1 [1]);
 474
 475                         _list1.RemoveRange (0, 0);
 476                         Assert.AreEqual (count - 2, _list1.Count);
 477                 }
 478
 479                 [Test]
 480                 public void RemoveRangeFromEmptyListTest ()
 481                 {
 482                         List<int> l = new List<int> ();
 483                         l.RemoveRange (0, 0);
 484                 }
 485
 486                 [Test, ExpectedException (typeof (ArgumentException))]
 487                 public void RemoveRangeOutOfRangeTest ()
 488                 {
 489                         _list1.RemoveRange (1, _list1.Count);
 490                 }
 491
 492                 [Test]
 493                 public void ReverseTest ()
 494                 {
 495                         int count = _list1.Count;
 496                         _list1.Reverse ();
 497                         Assert.AreEqual (count, _list1.Count);
 498
 499                         Assert.AreEqual (63, _list1 [0]);
 500                         Assert.AreEqual (55, _list1 [count - 1]);
 501
 502                         _list1.Reverse (0, 2);
 503
 504                         Assert.AreEqual (40, _list1 [0]);
 505                         Assert.AreEqual (63, _list1 [1]);
 506                 }
 507
 508                 [Test, ExpectedException (typeof (ArgumentException))]
 509                 public void ReverseOutOfRangeTest ()
 510                 {
 511                         _list1.Reverse (1, _list1.Count);
 512                 }
 513
 514                 [Test]
 515                 public void ToArrayTest ()
 516                 {
 517                         int [] copiedContents = _list1.ToArray ();
 518                         Assert.IsFalse (ReferenceEquals (copiedContents, _list1_contents));
 519
 520                         Assert.AreEqual (_list1.Count, copiedContents.Length);
 521                         Assert.AreEqual (_list1 [0], copiedContents [0]);
 522                 }
 523
 524                 [Test]
 525                 public void TrimExcessTest ()
 526                 {
 527                         List <string> l = new List <string> ();
 528                         l.Add ("foo");
 529
 530                         Assert.IsTrue (l.Count < l.Capacity);
 531                         l.TrimExcess ();
 532                         Assert.AreEqual (l.Count, l.Capacity);
 533                 }
 534
 535                 bool IsPositive (int i)
 536                 {
 537                         return i >= 0;
 538                 }
 539
 540                 [Test]
 541                 public void TrueForAllTest ()
 542                 {
 543                         Assert.IsFalse (_list1.TrueForAll (FindMultipleOfFour));
 544                         Assert.IsTrue (_list1.TrueForAll (IsPositive));
 545                 }
 546
 547                 [Test, ExpectedException (typeof (ArgumentNullException))]
 548                 public void TrueForAllNullTest ()
 549                 {
 550                         _list1.TrueForAll (null);
 551                 }
 552
 553                 [Test, ExpectedException (typeof (ArgumentOutOfRangeException))]
 554                 public void CapacityOutOfRangeTest ()
 555                 {
 556                         _list1.Capacity = _list1.Count - 1;
 557                 }
 558         }
 559 }
 560 #endif
 561