mcs/class/Mono.C5/Test/arrays/ArrayListTest.cs

   1 /*\r
   2  Copyright (c) 2003-2006 Niels Kokholm and Peter Sestoft\r
   3  Permission is hereby granted, free of charge, to any person obtaining a copy\r
   4  of this software and associated documentation files (the "Software"), to deal\r
   5  in the Software without restriction, including without limitation the rights\r
   6  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r
   7  copies of the Software, and to permit persons to whom the Software is\r
   8  furnished to do so, subject to the following conditions:\r
   9  \r
  10  The above copyright notice and this permission notice shall be included in\r
  11  all copies or substantial portions of the Software.\r
  12  \r
  13  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  14  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
  15  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r
  16  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r
  17  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
  18  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
  19  SOFTWARE.\r
  20 */\r
  21 \r
  22 using System;\r
  23 using C5;\r
  24 using NUnit.Framework;\r
  25 using SCG = System.Collections.Generic;\r
  26 \r
  27 namespace C5UnitTests.arrays.list\r
  28 {\r
  29   using CollectionOfInt = ArrayList<int>;\r
  30 \r
  31   [TestFixture]\r
  32   public class GenericTesters\r
  33   {\r
  34     [Test]\r
  35     public void TestEvents()\r
  36     {\r
  37       Fun<CollectionOfInt> factory = delegate() { return new CollectionOfInt(TenEqualityComparer.Default); };\r
  38       new C5UnitTests.Templates.Events.ListTester<CollectionOfInt>().Test(factory);\r
  39       new C5UnitTests.Templates.Events.QueueTester<CollectionOfInt>().Test(factory);\r
  40       new C5UnitTests.Templates.Events.StackTester<CollectionOfInt>().Test(factory);\r
  41     }\r
  42 \r
  43     [Test]\r
  44     public void Extensible()\r
  45     {\r
  46       C5UnitTests.Templates.Extensible.Clone.Tester<CollectionOfInt>();\r
  47       C5UnitTests.Templates.Extensible.Clone.ViewTester<CollectionOfInt>();\r
  48       C5UnitTests.Templates.Extensible.Serialization.Tester<CollectionOfInt>();\r
  49       C5UnitTests.Templates.Extensible.Serialization.ViewTester<CollectionOfInt>();\r
  50     }\r
  51   }\r
  52 \r
  53   static class Factory\r
  54   {\r
  55     public static ICollection<T> New<T>() { return new ArrayList<T>(); }\r
  56   }\r
  57 \r
  58   namespace Events\r
  59   {\r
  60     [TestFixture]\r
  61     public class IList_\r
  62     {\r
  63       private ArrayList<int> list;\r
  64       CollectionEventList<int> seen;\r
  65 \r
  66       [SetUp]\r
  67       public void Init()\r
  68       {\r
  69         list = new ArrayList<int>(TenEqualityComparer.Default);\r
  70         seen = new CollectionEventList<int>(IntEqualityComparer.Default);\r
  71       }\r
  72 \r
  73       private void listen() { seen.Listen(list, EventTypeEnum.Added); }\r
  74 \r
  75       [Test]\r
  76       public void Listenable()\r
  77       {\r
  78         Assert.AreEqual(EventTypeEnum.All, list.ListenableEvents);\r
  79         Assert.AreEqual(EventTypeEnum.None, list.ActiveEvents);\r
  80         listen();\r
  81         Assert.AreEqual(EventTypeEnum.Added, list.ActiveEvents);\r
  82       }\r
  83 \r
  84       [Test]\r
  85       public void SetThis()\r
  86       {\r
  87         list.Add(4); list.Add(56); list.Add(8);\r
  88         listen();\r
  89         list[1] = 45;\r
  90         seen.Check(new CollectionEvent<int>[] {\r
  91           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(56, 1), list),\r
  92           new CollectionEvent<int>(EventTypeEnum.RemovedAt, new ItemAtEventArgs<int>(56,1), list),\r
  93           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(45, 1), list),\r
  94           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(45,1), list),\r
  95           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
  96           });\r
  97       }\r
  98 \r
  99       [Test]\r
 100       public void Insert()\r
 101       {\r
 102         list.Add(4); list.Add(56); list.Add(8);\r
 103         listen();\r
 104         list.Insert(1, 45);\r
 105         seen.Check(new CollectionEvent<int>[] {\r
 106           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(45,1), list),\r
 107           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(45, 1), list),\r
 108           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 109           });\r
 110       }\r
 111 \r
 112       [Test]\r
 113       public void InsertAll()\r
 114       {\r
 115         list.Add(4); list.Add(56); list.Add(8);\r
 116         listen();\r
 117         list.InsertAll<int>(1, new int[] { 666, 777, 888 });\r
 118         //seen.Print(Console.Error);\r
 119         seen.Check(new CollectionEvent<int>[] {\r
 120           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(666,1), list),\r
 121           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(666, 1), list),\r
 122           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(777,2), list),\r
 123           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(777, 1), list),\r
 124           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(888,3), list),\r
 125           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(888, 1), list),\r
 126           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 127           });\r
 128         list.InsertAll<int>(1, new int[] {});\r
 129         seen.Check(new CollectionEvent<int>[] {});\r
 130       }\r
 131 \r
 132       [Test]\r
 133       public void InsertFirstLast()\r
 134       {\r
 135         list.Add(4); list.Add(56); list.Add(8);\r
 136         listen();\r
 137         list.InsertFirst(45);\r
 138         seen.Check(new CollectionEvent<int>[] {\r
 139           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(45,0), list),\r
 140           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(45, 1), list),\r
 141           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 142           });\r
 143         list.InsertLast(88);\r
 144         seen.Check(new CollectionEvent<int>[] {\r
 145           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(88,4), list),\r
 146           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(88, 1), list),\r
 147           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 148           });\r
 149       }\r
 150 \r
 151       [Test]\r
 152       public void Remove()\r
 153       {\r
 154         list.Add(4); list.Add(56); list.Add(8);\r
 155         listen();\r
 156         list.Remove();\r
 157         seen.Check(new CollectionEvent<int>[] {\r
 158           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(8, 1), list),\r
 159           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 160       }\r
 161 \r
 162       [Test]\r
 163       public void RemoveFirst()\r
 164       {\r
 165         list.Add(4); list.Add(56); list.Add(8);\r
 166         listen();\r
 167         list.RemoveFirst();\r
 168         seen.Check(new CollectionEvent<int>[] {\r
 169           new CollectionEvent<int>(EventTypeEnum.RemovedAt, new ItemAtEventArgs<int>(4,0), list),\r
 170           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(4, 1), list),\r
 171           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 172       }\r
 173 \r
 174       [Test]\r
 175       public void RemoveLast()\r
 176       {\r
 177         list.Add(4); list.Add(56); list.Add(8);\r
 178         listen();\r
 179         list.RemoveLast();\r
 180         seen.Check(new CollectionEvent<int>[] {\r
 181           new CollectionEvent<int>(EventTypeEnum.RemovedAt, new ItemAtEventArgs<int>(8,2), list),\r
 182           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(8, 1), list),\r
 183           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 184       }\r
 185 \r
 186       [Test]\r
 187       public void Reverse()\r
 188       {\r
 189         list.Add(4); list.Add(56); list.Add(8);\r
 190         listen();\r
 191         list.Reverse();\r
 192         seen.Check(new CollectionEvent<int>[] {\r
 193           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 194         });\r
 195         list.View(1, 0).Reverse();\r
 196         seen.Check(new CollectionEvent<int>[] {});\r
 197       }\r
 198 \r
 199 \r
 200       [Test]\r
 201       public void Sort()\r
 202       {\r
 203         list.Add(4); list.Add(56); list.Add(8);\r
 204         listen();\r
 205         list.Sort();\r
 206         seen.Check(new CollectionEvent<int>[] {\r
 207           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 208         });\r
 209         list.View(1, 0).Sort();\r
 210         seen.Check(new CollectionEvent<int>[] {});\r
 211       }\r
 212 \r
 213       [Test]\r
 214       public void Shuffle()\r
 215       {\r
 216         list.Add(4); list.Add(56); list.Add(8);\r
 217         listen();\r
 218         list.Shuffle();\r
 219         seen.Check(new CollectionEvent<int>[] {\r
 220           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 221         });\r
 222         list.View(1, 0).Shuffle();\r
 223         seen.Check(new CollectionEvent<int>[] {});\r
 224       }\r
 225 \r
 226       [Test]\r
 227       public void RemoveAt()\r
 228       {\r
 229         list.Add(4); list.Add(56); list.Add(8);\r
 230         listen();\r
 231         list.RemoveAt(1);\r
 232         seen.Check(new CollectionEvent<int>[] {\r
 233           new CollectionEvent<int>(EventTypeEnum.RemovedAt, new ItemAtEventArgs<int>(56,1), list),\r
 234           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(56, 1), list),\r
 235           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 236       }\r
 237 \r
 238       [Test]\r
 239       public void RemoveInterval()\r
 240       {\r
 241         list.Add(4); list.Add(56); list.Add(8);\r
 242         listen();\r
 243         list.RemoveInterval(1, 2);\r
 244         seen.Check(new CollectionEvent<int>[] {\r
 245            new CollectionEvent<int>(EventTypeEnum.Cleared, new ClearedRangeEventArgs(false,2,1), list),\r
 246          new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 247         });\r
 248         list.RemoveInterval(1, 0);\r
 249         seen.Check(new CollectionEvent<int>[] {});\r
 250       }\r
 251 \r
 252       [Test]\r
 253       public void Update()\r
 254       {\r
 255         list.Add(4); list.Add(56); list.Add(8);\r
 256         listen();\r
 257         list.Update(53);\r
 258         seen.Check(new CollectionEvent<int>[] {\r
 259           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(56, 1), list),\r
 260           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(53, 1), list),\r
 261           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 262           });\r
 263         list.Update(67);\r
 264         seen.Check(new CollectionEvent<int>[] {});\r
 265       }\r
 266 \r
 267       [Test]\r
 268       public void FindOrAdd()\r
 269       {\r
 270         list.Add(4); list.Add(56); list.Add(8);\r
 271         listen();\r
 272         int val = 53;\r
 273         list.FindOrAdd(ref val);\r
 274         seen.Check(new CollectionEvent<int>[] {});\r
 275         val = 67;\r
 276         list.FindOrAdd(ref val);\r
 277         seen.Check(new CollectionEvent<int>[] { \r
 278           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(67, 1), list),\r
 279           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 280         });\r
 281       }\r
 282 \r
 283       [Test]\r
 284       public void UpdateOrAdd()\r
 285       {\r
 286         list.Add(4); list.Add(56); list.Add(8);\r
 287         listen();\r
 288         int val = 53;\r
 289         list.UpdateOrAdd(val);\r
 290         seen.Check(new CollectionEvent<int>[] {\r
 291           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(56, 1), list),\r
 292           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(53, 1), list),\r
 293           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 294         });\r
 295         val = 67;\r
 296         list.UpdateOrAdd(val);\r
 297         seen.Check(new CollectionEvent<int>[] { \r
 298           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(67, 1), list),\r
 299           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 300         });\r
 301         list.UpdateOrAdd(51, out val);\r
 302         seen.Check(new CollectionEvent<int>[] {\r
 303           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(53, 1), list),\r
 304           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(51, 1), list),\r
 305           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 306         });\r
 307         val = 67;\r
 308         list.UpdateOrAdd(81, out val);\r
 309         seen.Check(new CollectionEvent<int>[] { \r
 310           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(81, 1), list),\r
 311           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 312         });\r
 313       }\r
 314 \r
 315       [Test]\r
 316       public void RemoveItem()\r
 317       {\r
 318         list.Add(4); list.Add(56); list.Add(18);\r
 319         listen();\r
 320         list.Remove(53);\r
 321         seen.Check(new CollectionEvent<int>[] {\r
 322           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(56, 1), list),\r
 323           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 324         list.Remove(11);\r
 325         seen.Check(new CollectionEvent<int>[] {\r
 326           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(18, 1), list),\r
 327           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 328       }\r
 329 \r
 330       [Test]\r
 331       public void RemoveAll()\r
 332       {\r
 333         for (int i = 0; i < 10; i++)\r
 334         {\r
 335           list.Add(10 * i + 5);\r
 336         }\r
 337         listen();\r
 338         list.RemoveAll<int>(new int[] { 32, 187, 45 });\r
 339         //TODO: the order depends on internals of the HashSet\r
 340         seen.Check(new CollectionEvent<int>[] {\r
 341           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(35, 1), list),\r
 342           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(45, 1), list),\r
 343           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 344         list.RemoveAll<int>(new int[] { 200, 300 });\r
 345         seen.Check(new CollectionEvent<int>[] {});\r
 346       }\r
 347 \r
 348       [Test]\r
 349       public void Clear()\r
 350       {\r
 351         list.Add(4); list.Add(56); list.Add(8);\r
 352         listen();\r
 353         list.View(1, 1).Clear();\r
 354         seen.Check(new CollectionEvent<int>[] {\r
 355           new CollectionEvent<int>(EventTypeEnum.Cleared, new ClearedRangeEventArgs(false,1,1), list),\r
 356           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 357         });\r
 358         list.Clear();\r
 359         seen.Check(new CollectionEvent<int>[] {\r
 360           new CollectionEvent<int>(EventTypeEnum.Cleared, new ClearedRangeEventArgs(true,2,0), list),\r
 361           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 362         });\r
 363         list.Clear();\r
 364         seen.Check(new CollectionEvent<int>[] {});\r
 365       }\r
 366 \r
 367       [Test]\r
 368       public void ListDispose()\r
 369       {\r
 370         list.Add(4); list.Add(56); list.Add(8);\r
 371         listen();\r
 372         list.View(1, 1).Dispose();\r
 373         seen.Check(new CollectionEvent<int>[] {});\r
 374         list.Dispose();\r
 375         seen.Check(new CollectionEvent<int>[] {\r
 376           new CollectionEvent<int>(EventTypeEnum.Cleared, new ClearedRangeEventArgs(true,3,0), list),\r
 377           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)\r
 378         });\r
 379         list.Dispose();\r
 380         seen.Check(new CollectionEvent<int>[] {});\r
 381       }\r
 382 \r
 383 \r
 384       [Test]\r
 385       public void RetainAll()\r
 386       {\r
 387         for (int i = 0; i < 10; i++)\r
 388         {\r
 389           list.Add(10 * i + 5);\r
 390         }\r
 391         listen();\r
 392         list.RetainAll<int>(new int[] { 32, 187, 45, 62, 82, 95, 2 });\r
 393         seen.Check(new CollectionEvent<int>[] {\r
 394           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(15, 1), list),\r
 395           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(25, 1), list),\r
 396           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(55, 1), list),\r
 397           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(75, 1), list),\r
 398           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 399         list.RetainAll<int>(new int[] { 32, 187, 45, 62, 82, 95, 2 });\r
 400         seen.Check(new CollectionEvent<int>[] {});\r
 401       }\r
 402 \r
 403       [Test]\r
 404       public void RemoveAllCopies()\r
 405       {\r
 406         for (int i = 0; i < 10; i++)\r
 407         {\r
 408           list.Add(3 * i + 5);\r
 409         }\r
 410         listen();\r
 411         list.RemoveAllCopies(14);\r
 412         seen.Check(new CollectionEvent<int>[] {\r
 413           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(11, 1), list),\r
 414           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(14, 1), list),\r
 415           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(17, 1), list),\r
 416           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 417         list.RemoveAllCopies(14);\r
 418         seen.Check(new CollectionEvent<int>[] {});\r
 419       }\r
 420 \r
 421       [Test]\r
 422       public void Add()\r
 423       {\r
 424         listen();\r
 425         seen.Check(new CollectionEvent<int>[0]);\r
 426         list.Add(23);\r
 427         seen.Check(new CollectionEvent<int>[] {\r
 428           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(23, 1), list),\r
 429           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 430       }\r
 431 \r
 432       [Test]\r
 433       public void AddAll()\r
 434       {\r
 435         for (int i = 0; i < 10; i++)\r
 436         {\r
 437           list.Add(10 * i + 5);\r
 438         }\r
 439         listen();\r
 440         list.AddAll<int>(new int[] { 45, 56, 67 });\r
 441         seen.Check(new CollectionEvent<int>[] {\r
 442           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(45, 1), list),\r
 443           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(56, 1), list),\r
 444           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(67, 1), list),\r
 445           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 446         list.AddAll<int>(new int[] { });\r
 447         seen.Check(new CollectionEvent<int>[] {});\r
 448       }\r
 449 \r
 450       [TearDown]\r
 451       public void Dispose() { list = null; seen = null; }\r
 452 \r
 453       [Test]\r
 454       [ExpectedException(typeof(UnlistenableEventException))]\r
 455       public void ViewChanged()\r
 456       {\r
 457         IList<int> w = list.View(0, 0);\r
 458         w.CollectionChanged += new CollectionChangedHandler<int>(w_CollectionChanged);\r
 459       }\r
 460 \r
 461       [Test]\r
 462       [ExpectedException(typeof(UnlistenableEventException))]\r
 463       public void ViewCleared()\r
 464       {\r
 465         IList<int> w = list.View(0, 0);\r
 466         w.CollectionCleared += new CollectionClearedHandler<int>(w_CollectionCleared);\r
 467       }\r
 468 \r
 469       [Test]\r
 470       [ExpectedException(typeof(UnlistenableEventException))]\r
 471       public void ViewAdded()\r
 472       {\r
 473         IList<int> w = list.View(0, 0);\r
 474         w.ItemsAdded += new ItemsAddedHandler<int>(w_ItemAdded);\r
 475       }\r
 476 \r
 477       [Test]\r
 478       [ExpectedException(typeof(UnlistenableEventException))]\r
 479       public void ViewInserted()\r
 480       {\r
 481         IList<int> w = list.View(0, 0);\r
 482         w.ItemInserted += new ItemInsertedHandler<int>(w_ItemInserted);\r
 483       }\r
 484 \r
 485       [Test]\r
 486       [ExpectedException(typeof(UnlistenableEventException))]\r
 487       public void ViewRemoved()\r
 488       {\r
 489         IList<int> w = list.View(0, 0);\r
 490         w.ItemsRemoved += new ItemsRemovedHandler<int>(w_ItemRemoved);\r
 491       }\r
 492 \r
 493       [Test]\r
 494       [ExpectedException(typeof(UnlistenableEventException))]\r
 495       public void ViewRemovedAt()\r
 496       {\r
 497         IList<int> w = list.View(0, 0);\r
 498         w.ItemRemovedAt += new ItemRemovedAtHandler<int>(w_ItemRemovedAt);\r
 499       }\r
 500 \r
 501       void w_CollectionChanged(object sender)\r
 502       {\r
 503         throw new NotImplementedException();\r
 504       }\r
 505 \r
 506       void w_CollectionCleared(object sender, ClearedEventArgs eventArgs)\r
 507       {\r
 508         throw new NotImplementedException();\r
 509       }\r
 510 \r
 511       void w_ItemAdded(object sender, ItemCountEventArgs<int> eventArgs)\r
 512       {\r
 513         throw new NotImplementedException();\r
 514       }\r
 515 \r
 516       void w_ItemInserted(object sender, ItemAtEventArgs<int> eventArgs)\r
 517       {\r
 518         throw new NotImplementedException();\r
 519       }\r
 520 \r
 521       void w_ItemRemoved(object sender, ItemCountEventArgs<int> eventArgs)\r
 522       {\r
 523         throw new NotImplementedException();\r
 524       }\r
 525 \r
 526       void w_ItemRemovedAt(object sender, ItemAtEventArgs<int> eventArgs)\r
 527       {\r
 528         throw new NotImplementedException();\r
 529       }\r
 530     }\r
 531 \r
 532     [TestFixture]\r
 533     public class StackQueue\r
 534     {\r
 535 \r
 536       private ArrayList<int> list;\r
 537       CollectionEventList<int> seen;\r
 538 \r
 539       [SetUp]\r
 540       public void Init()\r
 541       {\r
 542         list = new ArrayList<int>(TenEqualityComparer.Default);\r
 543         seen = new CollectionEventList<int>(IntEqualityComparer.Default);\r
 544       }\r
 545 \r
 546       private void listen() { seen.Listen(list, EventTypeEnum.All); }\r
 547 \r
 548       [Test]\r
 549       public void EnqueueDequeue()\r
 550       {\r
 551         listen();\r
 552         list.Enqueue(67);\r
 553         seen.Check(new CollectionEvent<int>[] {\r
 554           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(67,0), list),\r
 555           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(67, 1), list),\r
 556           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 557         list.Enqueue(2);\r
 558         seen.Check(new CollectionEvent<int>[] {\r
 559           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(2,1), list),\r
 560           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(2, 1), list),\r
 561           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 562         list.Dequeue();\r
 563         seen.Check(new CollectionEvent<int>[] {\r
 564           new CollectionEvent<int>(EventTypeEnum.RemovedAt, new ItemAtEventArgs<int>(67,0), list),\r
 565           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(67, 1), list),\r
 566           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 567         list.Dequeue();\r
 568         seen.Check(new CollectionEvent<int>[] {\r
 569           new CollectionEvent<int>(EventTypeEnum.RemovedAt, new ItemAtEventArgs<int>(2,0), list),\r
 570           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(2, 1), list),\r
 571           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 572       }\r
 573 \r
 574       [Test]\r
 575       public void PushPop()\r
 576       {\r
 577         listen();\r
 578         seen.Check(new CollectionEvent<int>[0]);\r
 579         list.Push(23);\r
 580         seen.Check(new CollectionEvent<int>[] {\r
 581           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(23,0), list),\r
 582           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(23, 1), list),\r
 583           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 584         list.Push(-12);\r
 585         seen.Check(new CollectionEvent<int>[] {\r
 586           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(-12,1), list),\r
 587           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(-12, 1), list),\r
 588           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 589         list.Pop();\r
 590         seen.Check(new CollectionEvent<int>[] {\r
 591           new CollectionEvent<int>(EventTypeEnum.RemovedAt, new ItemAtEventArgs<int>(-12,1), list),\r
 592           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(-12, 1), list),\r
 593           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 594         list.Pop();\r
 595         seen.Check(new CollectionEvent<int>[] {\r
 596           new CollectionEvent<int>(EventTypeEnum.RemovedAt, new ItemAtEventArgs<int>(23,0), list),\r
 597           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(23, 1), list),\r
 598           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), list)});\r
 599       }\r
 600 \r
 601       [TearDown]\r
 602       public void Dispose() { list = null; seen = null; }\r
 603     }\r
 604   }\r
 605 \r
 606   namespace Safety\r
 607   {\r
 608     /// <summary>\r
 609     /// Tests to see if the collection classes are robust for enumerable arguments that throw exceptions.\r
 610     /// </summary>\r
 611     [TestFixture]\r
 612     public class BadEnumerable\r
 613     {\r
 614       private ArrayList<int> list;\r
 615 \r
 616       [SetUp]\r
 617       public void Init()\r
 618       {\r
 619         list = new ArrayList<int>();\r
 620       }\r
 621 \r
 622       [Test]\r
 623       public void InsertAll()\r
 624       {\r
 625         list.Add(4); list.Add(56); list.Add(8);\r
 626         try\r
 627         {\r
 628           list.InsertAll<int>(1, new BadEnumerable<int>(new BadEnumerableException(), 9, 8, 7));\r
 629           Assert.Fail("Should not get here");\r
 630         }\r
 631         catch (BadEnumerableException) { }\r
 632         Assert.IsTrue(list.Check());\r
 633         Assert.IsTrue(IC.eq(list, 4, 9, 8, 7, 56, 8));\r
 634 \r
 635       }\r
 636 \r
 637       [Test]\r
 638       public void AddAll()\r
 639       {\r
 640         list.Add(4); list.Add(56); list.Add(8);\r
 641         try\r
 642         {\r
 643           list.View(0, 1).AddAll<int>(new BadEnumerable<int>(new BadEnumerableException(), 9, 8, 7));\r
 644           Assert.Fail("Should not get here");\r
 645         }\r
 646         catch (BadEnumerableException) { }\r
 647         Assert.IsTrue(list.Check());\r
 648         Assert.IsTrue(IC.eq(list, 4, 9, 8, 7, 56, 8));\r
 649       }\r
 650 \r
 651       [Test]\r
 652       public void RemoveAll()\r
 653       {\r
 654         list.Add(4); list.Add(56); list.Add(8);\r
 655         try\r
 656         {\r
 657           list.RemoveAll(new BadEnumerable<int>(new BadEnumerableException(), 9, 8, 7));\r
 658           Assert.Fail("Should not get here");\r
 659         }\r
 660         catch (BadEnumerableException) { }\r
 661         Assert.IsTrue(list.Check());\r
 662         Assert.IsTrue(IC.eq(list, 4, 56, 8));\r
 663       }\r
 664 \r
 665       [Test]\r
 666       public void RetainAll()\r
 667       {\r
 668         list.Add(4); list.Add(56); list.Add(8);\r
 669         try\r
 670         {\r
 671           list.RetainAll(new BadEnumerable<int>(new BadEnumerableException(), 9, 8, 7));\r
 672           Assert.Fail("Should not get here");\r
 673         }\r
 674         catch (BadEnumerableException) { }\r
 675         Assert.IsTrue(list.Check());\r
 676         Assert.IsTrue(IC.eq(list, 4, 56, 8));\r
 677       }\r
 678 \r
 679 \r
 680       [Test]\r
 681       public void ContainsAll()\r
 682       {\r
 683         list.Add(4); list.Add(56); list.Add(8);\r
 684         try\r
 685         {\r
 686           list.ContainsAll(new BadEnumerable<int>(new BadEnumerableException(), 4, 18));\r
 687           Assert.Fail("Should not get here");\r
 688         }\r
 689         catch (BadEnumerableException) { }\r
 690         Assert.IsTrue(list.Check());\r
 691         Assert.IsTrue(IC.eq(list, 4, 56, 8));\r
 692       }\r
 693 \r
 694 \r
 695       [TearDown]\r
 696       public void Dispose() { list = null; }\r
 697     }\r
 698 \r
 699     /// <summary>\r
 700     /// Tests to see if the collection classes are robust for delegate arguments that throw exceptions.\r
 701     /// </summary>\r
 702     [TestFixture]\r
 703     public class BadFun\r
 704     {\r
 705       private ArrayList<int> list;\r
 706 \r
 707       [SetUp]\r
 708       public void Init()\r
 709       {\r
 710         list = new ArrayList<int>();\r
 711       }\r
 712 \r
 713       [Test]\r
 714       public void NoTests() { }\r
 715 \r
 716       [TearDown]\r
 717       public void Dispose() { list = null; }\r
 718     }\r
 719   }\r
 720 \r
 721   namespace Enumerable\r
 722   {\r
 723     [TestFixture]\r
 724     public class Multiops\r
 725     {\r
 726       private ArrayList<int> list;\r
 727 \r
 728       private Fun<int, bool> always, never, even;\r
 729 \r
 730 \r
 731       [SetUp]\r
 732       public void Init()\r
 733       {\r
 734         list = new ArrayList<int>();\r
 735         always = delegate { return true; };\r
 736         never = delegate { return false; };\r
 737         even = delegate(int i) { return i % 2 == 0; };\r
 738       }\r
 739 \r
 740 \r
 741       [Test]\r
 742       public void All()\r
 743       {\r
 744         Assert.IsTrue(list.All(always));\r
 745         Assert.IsTrue(list.All(never));\r
 746         Assert.IsTrue(list.All(even));\r
 747         list.Add(8);\r
 748         Assert.IsTrue(list.All(always));\r
 749         Assert.IsFalse(list.All(never));\r
 750         Assert.IsTrue(list.All(even));\r
 751         list.Add(5);\r
 752         Assert.IsTrue(list.All(always));\r
 753         Assert.IsFalse(list.All(never));\r
 754         Assert.IsFalse(list.All(even));\r
 755       }\r
 756 \r
 757 \r
 758       [Test]\r
 759       public void Exists()\r
 760       {\r
 761         Assert.IsFalse(list.Exists(always));\r
 762         Assert.IsFalse(list.Exists(never));\r
 763         Assert.IsFalse(list.Exists(even));\r
 764         list.Add(5);\r
 765         Assert.IsTrue(list.Exists(always));\r
 766         Assert.IsFalse(list.Exists(never));\r
 767         Assert.IsFalse(list.Exists(even));\r
 768         list.Add(8);\r
 769         Assert.IsTrue(list.Exists(always));\r
 770         Assert.IsFalse(list.Exists(never));\r
 771         Assert.IsTrue(list.Exists(even));\r
 772       }\r
 773 \r
 774 \r
 775       [Test]\r
 776       public void Apply()\r
 777       {\r
 778         int sum = 0;\r
 779         Act<int> a = delegate(int i) { sum = i + 10 * sum; };\r
 780 \r
 781         list.Apply(a);\r
 782         Assert.AreEqual(0, sum);\r
 783         sum = 0;\r
 784         list.Add(5); list.Add(8); list.Add(7); list.Add(5);\r
 785         list.Apply(a);\r
 786         Assert.AreEqual(5875, sum);\r
 787       }\r
 788 \r
 789 \r
 790       [TearDown]\r
 791       public void Dispose() { list = null; }\r
 792     }\r
 793 \r
 794 \r
 795 \r
 796     [TestFixture]\r
 797     public class GetEnumerator\r
 798     {\r
 799       private ArrayList<int> list;\r
 800 \r
 801 \r
 802       [SetUp]\r
 803       public void Init() { list = new ArrayList<int>(); }\r
 804 \r
 805 \r
 806       [Test]\r
 807       public void Empty()\r
 808       {\r
 809         SCG.IEnumerator<int> e = list.GetEnumerator();\r
 810 \r
 811         Assert.IsFalse(e.MoveNext());\r
 812       }\r
 813 \r
 814 \r
 815       [Test]\r
 816       public void Normal()\r
 817       {\r
 818         list.Add(5);\r
 819         list.Add(8);\r
 820         list.Add(5);\r
 821         list.Add(5);\r
 822         list.Add(10);\r
 823         list.Add(1);\r
 824 \r
 825         SCG.IEnumerator<int> e = list.GetEnumerator();\r
 826 \r
 827         Assert.IsTrue(e.MoveNext());\r
 828         Assert.AreEqual(5, e.Current);\r
 829         Assert.IsTrue(e.MoveNext());\r
 830         Assert.AreEqual(8, e.Current);\r
 831         Assert.IsTrue(e.MoveNext());\r
 832         Assert.AreEqual(5, e.Current);\r
 833         Assert.IsTrue(e.MoveNext());\r
 834         Assert.AreEqual(5, e.Current);\r
 835         Assert.IsTrue(e.MoveNext());\r
 836         Assert.AreEqual(10, e.Current);\r
 837         Assert.IsTrue(e.MoveNext());\r
 838         Assert.AreEqual(1, e.Current);\r
 839         Assert.IsFalse(e.MoveNext());\r
 840       }\r
 841 \r
 842 \r
 843       [Test]\r
 844       public void DoDispose()\r
 845       {\r
 846         list.Add(5);\r
 847         list.Add(8);\r
 848         list.Add(5);\r
 849 \r
 850         SCG.IEnumerator<int> e = list.GetEnumerator();\r
 851 \r
 852         e.MoveNext();\r
 853         e.MoveNext();\r
 854         e.Dispose();\r
 855       }\r
 856 \r
 857 \r
 858       [Test]\r
 859       [ExpectedException(typeof(CollectionModifiedException))]\r
 860       public void MoveNextAfterUpdate()\r
 861       {\r
 862         list.Add(5);\r
 863         list.Add(8);\r
 864         list.Add(5);\r
 865 \r
 866         SCG.IEnumerator<int> e = list.GetEnumerator();\r
 867 \r
 868         e.MoveNext();\r
 869         list.Add(99);\r
 870         e.MoveNext();\r
 871       }\r
 872 \r
 873       [TearDown]\r
 874       public void Dispose() { list = null; }\r
 875     }\r
 876   }\r
 877 \r
 878   namespace CollectionOrSink\r
 879   {\r
 880     [TestFixture]\r
 881     public class Formatting\r
 882     {\r
 883       ICollection<int> coll;\r
 884       IFormatProvider rad16;\r
 885       [SetUp]\r
 886       public void Init() { coll = Factory.New<int>(); rad16 = new RadixFormatProvider(16); }\r
 887       [TearDown]\r
 888       public void Dispose() { coll = null; rad16 = null; }\r
 889       [Test]\r
 890       public void Format()\r
 891       {\r
 892         Assert.AreEqual("[  ]", coll.ToString());\r
 893         coll.AddAll<int>(new int[] { -4, 28, 129, 65530 });\r
 894         Assert.AreEqual("[ 0:-4, 1:28, 2:129, 3:65530 ]", coll.ToString());\r
 895         Assert.AreEqual("[ 0:-4, 1:1C, 2:81, 3:FFFA ]", coll.ToString(null, rad16));\r
 896         Assert.AreEqual("[ 0:-4, 1:28... ]", coll.ToString("L14", null));\r
 897         Assert.AreEqual("[ 0:-4, 1:1C... ]", coll.ToString("L14", rad16));\r
 898       }\r
 899     }\r
 900 \r
 901     [TestFixture]\r
 902     public class CollectionOrSink\r
 903     {\r
 904       private ArrayList<int> list;\r
 905 \r
 906 \r
 907       [SetUp]\r
 908       public void Init() { list = new ArrayList<int>(); }\r
 909 \r
 910       [Test]\r
 911       public void Choose()\r
 912       {\r
 913         list.Add(7);\r
 914         Assert.AreEqual(7, list.Choose());\r
 915       }\r
 916 \r
 917       [Test]\r
 918       [ExpectedException(typeof(NoSuchItemException))]\r
 919       public void BadChoose()\r
 920       {\r
 921         list.Choose();\r
 922       }\r
 923 \r
 924       [Test]\r
 925       public void CountEtAl()\r
 926       {\r
 927         Assert.AreEqual(0, list.Count);\r
 928         Assert.IsTrue(list.IsEmpty);\r
 929         Assert.IsTrue(list.AllowsDuplicates);\r
 930         list.Add(5);\r
 931         Assert.AreEqual(1, list.Count);\r
 932         Assert.IsFalse(list.IsEmpty);\r
 933         list.Add(5);\r
 934         Assert.AreEqual(2, list.Count);\r
 935         Assert.IsFalse(list.IsEmpty);\r
 936         list.Add(8);\r
 937         Assert.AreEqual(3, list.Count);\r
 938       }\r
 939 \r
 940 \r
 941       [Test]\r
 942       public void AddAll()\r
 943       {\r
 944         list.Add(3); list.Add(4); list.Add(5);\r
 945 \r
 946         ArrayList<int> list2 = new ArrayList<int>();\r
 947 \r
 948         list2.AddAll(list);\r
 949         Assert.IsTrue(IC.eq(list2, 3, 4, 5));\r
 950         list.AddAll(list2);\r
 951         Assert.IsTrue(IC.eq(list2, 3, 4, 5));\r
 952         Assert.IsTrue(IC.eq(list, 3, 4, 5, 3, 4, 5));\r
 953       }\r
 954 \r
 955 \r
 956       [TearDown]\r
 957       public void Dispose() { list = null; }\r
 958     }\r
 959 \r
 960     [TestFixture]\r
 961     public class FindPredicate\r
 962     {\r
 963       private ArrayList<int> list;\r
 964       Fun<int, bool> pred;\r
 965 \r
 966       [SetUp]\r
 967       public void Init()\r
 968       {\r
 969         list = new ArrayList<int>(TenEqualityComparer.Default);\r
 970         pred = delegate(int i) { return i % 5 == 0; };\r
 971       }\r
 972 \r
 973       [TearDown]\r
 974       public void Dispose() { list = null; }\r
 975 \r
 976       [Test]\r
 977       public void Find()\r
 978       {\r
 979         int i;\r
 980         Assert.IsFalse(list.Find(pred, out i));\r
 981         list.AddAll<int>(new int[] { 4, 22, 67, 37 });\r
 982         Assert.IsFalse(list.Find(pred, out i));\r
 983         list.AddAll<int>(new int[] { 45, 122, 675, 137 });\r
 984         Assert.IsTrue(list.Find(pred, out i));\r
 985         Assert.AreEqual(45, i);\r
 986       }\r
 987 \r
 988       [Test]\r
 989       public void FindLast()\r
 990       {\r
 991         int i;\r
 992         Assert.IsFalse(list.FindLast(pred, out i));\r
 993         list.AddAll<int>(new int[] { 4, 22, 67, 37 });\r
 994         Assert.IsFalse(list.FindLast(pred, out i));\r
 995         list.AddAll<int>(new int[] { 45, 122, 675, 137 });\r
 996         Assert.IsTrue(list.FindLast(pred, out i));\r
 997         Assert.AreEqual(675, i);\r
 998       }\r
 999 \r
1000       [Test]\r
1001       public void FindIndex()\r
1002       {\r
1003         Assert.IsFalse(0 <= list.FindIndex(pred));\r
1004         list.AddAll<int>(new int[] { 4, 22, 67, 37 });\r
1005         Assert.IsFalse(0 <= list.FindIndex(pred));\r
1006         list.AddAll<int>(new int[] { 45, 122, 675, 137 });\r
1007         Assert.AreEqual(4, list.FindIndex(pred));\r
1008       }\r
1009 \r
1010       [Test]\r
1011       public void FindLastIndex()\r
1012       {\r
1013         Assert.IsFalse(0 <= list.FindLastIndex(pred));\r
1014         list.AddAll<int>(new int[] { 4, 22, 67, 37 });\r
1015         Assert.IsFalse(0 <= list.FindLastIndex(pred));\r
1016         list.AddAll<int>(new int[] { 45, 122, 675, 137 });\r
1017         Assert.AreEqual(6, list.FindLastIndex(pred));\r
1018       }\r
1019     }\r
1020 \r
1021     [TestFixture]\r
1022     public class UniqueItems\r
1023     {\r
1024       private ArrayList<int> list;\r
1025 \r
1026       [SetUp]\r
1027       public void Init() { list = new ArrayList<int>(); }\r
1028 \r
1029       [TearDown]\r
1030       public void Dispose() { list = null; }\r
1031 \r
1032       [Test]\r
1033       public void Test()\r
1034       {\r
1035         Assert.IsTrue(IC.seteq(list.UniqueItems()));\r
1036         Assert.IsTrue(IC.seteq(list.ItemMultiplicities()));\r
1037         list.AddAll<int>(new int[] { 7, 9, 7 });\r
1038         Assert.IsTrue(IC.seteq(list.UniqueItems(), 7, 9));\r
1039         Assert.IsTrue(IC.seteq(list.ItemMultiplicities(), 7, 2, 9, 1));\r
1040       }\r
1041     }\r
1042 \r
1043     [TestFixture]\r
1044     public class ArrayTest\r
1045     {\r
1046       private ArrayList<int> list;\r
1047 \r
1048       int[] a;\r
1049 \r
1050 \r
1051       [SetUp]\r
1052       public void Init()\r
1053       {\r
1054         list = new ArrayList<int>();\r
1055         a = new int[10];\r
1056         for (int i = 0; i < 10; i++)\r
1057           a[i] = 1000 + i;\r
1058       }\r
1059 \r
1060 \r
1061       [TearDown]\r
1062       public void Dispose() { list = null; }\r
1063 \r
1064 \r
1065       private string aeq(int[] a, params int[] b)\r
1066       {\r
1067         if (a.Length != b.Length)\r
1068           return "Lengths differ: " + a.Length + " != " + b.Length;\r
1069 \r
1070         for (int i = 0; i < a.Length; i++)\r
1071           if (a[i] != b[i])\r
1072             return String.Format("{0}'th elements differ: {1} != {2}", i, a[i], b[i]);\r
1073 \r
1074         return "Alles klar";\r
1075       }\r
1076 \r
1077 \r
1078       [Test]\r
1079       public void ToArray()\r
1080       {\r
1081         Assert.AreEqual("Alles klar", aeq(list.ToArray()));\r
1082         list.Add(7);\r
1083         list.Add(7);\r
1084         Assert.AreEqual("Alles klar", aeq(list.ToArray(), 7, 7));\r
1085       }\r
1086 \r
1087 \r
1088       [Test]\r
1089       public void CopyTo()\r
1090       {\r
1091         list.CopyTo(a, 1);\r
1092         Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009));\r
1093         list.Add(6);\r
1094         list.CopyTo(a, 2);\r
1095         Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 6, 1003, 1004, 1005, 1006, 1007, 1008, 1009));\r
1096         list.Add(4);\r
1097         list.Add(4);\r
1098         list.Add(9);\r
1099         list.CopyTo(a, 4);\r
1100         Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 6, 1003, 6, 4, 4, 9, 1008, 1009));\r
1101         list.Clear();\r
1102         list.Add(7);\r
1103         list.CopyTo(a, 9);\r
1104         Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 6, 1003, 6, 4, 4, 9, 1008, 7));\r
1105       }\r
1106 \r
1107 \r
1108       [Test]\r
1109       [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
1110       public void CopyToBad()\r
1111       {\r
1112         list.CopyTo(a, 11);\r
1113       }\r
1114 \r
1115 \r
1116       [Test]\r
1117       [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
1118       public void CopyToBad2()\r
1119       {\r
1120         list.CopyTo(a, -1);\r
1121       }\r
1122 \r
1123 \r
1124       [Test]\r
1125       [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
1126       public void CopyToTooFar()\r
1127       {\r
1128         list.Add(3);\r
1129         list.Add(3);\r
1130         list.CopyTo(a, 9);\r
1131       }\r
1132     }\r
1133 \r
1134     [TestFixture]\r
1135     public class Sync\r
1136     {\r
1137       private ArrayList<int> list;\r
1138 \r
1139 \r
1140       [SetUp]\r
1141       public void Init()\r
1142       {\r
1143         list = new ArrayList<int>();\r
1144       }\r
1145 \r
1146 \r
1147       [TearDown]\r
1148       public void Dispose() { list = null; }\r
1149 \r
1150 \r
1151       [Test]\r
1152       public void Get()\r
1153       {\r
1154         Assert.IsNotNull(list.SyncRoot);\r
1155       }\r
1156     }\r
1157   }\r
1158 \r
1159 \r
1160 \r
1161 \r
1162   namespace EditableCollection\r
1163   {\r
1164     [TestFixture]\r
1165     public class Searching\r
1166     {\r
1167       private ArrayList<int> list;\r
1168 \r
1169 \r
1170       [SetUp]\r
1171       public void Init() { list = new ArrayList<int>(); }\r
1172 \r
1173       [Test]\r
1174       [ExpectedException(typeof(NullReferenceException))]\r
1175       public void NullEqualityComparerinConstructor1()\r
1176       {\r
1177         new ArrayList<int>(null);\r
1178       }\r
1179 \r
1180       [Test]\r
1181       [ExpectedException(typeof(NullReferenceException))]\r
1182       public void NullEqualityComparerinConstructor2()\r
1183       {\r
1184         new ArrayList<int>(5, null);\r
1185       }\r
1186 \r
1187       [Test]\r
1188       public void Contains()\r
1189       {\r
1190         Assert.IsFalse(list.Contains(5));\r
1191         list.Add(5);\r
1192         Assert.IsTrue(list.Contains(5));\r
1193         Assert.IsFalse(list.Contains(7));\r
1194         list.Add(8);\r
1195         list.Add(10);\r
1196         Assert.IsTrue(list.Contains(5));\r
1197         Assert.IsFalse(list.Contains(7));\r
1198         Assert.IsTrue(list.Contains(8));\r
1199         Assert.IsTrue(list.Contains(10));\r
1200         list.Remove(8);\r
1201         Assert.IsTrue(list.Contains(5));\r
1202         Assert.IsFalse(list.Contains(7));\r
1203         Assert.IsFalse(list.Contains(8));\r
1204         Assert.IsTrue(list.Contains(10));\r
1205       }\r
1206 \r
1207 \r
1208       [Test]\r
1209       public void ContainsCount()\r
1210       {\r
1211         Assert.AreEqual(0, list.ContainsCount(5));\r
1212         list.Add(5);\r
1213         Assert.AreEqual(1, list.ContainsCount(5));\r
1214         Assert.AreEqual(0, list.ContainsCount(7));\r
1215         list.Add(8);\r
1216         Assert.AreEqual(1, list.ContainsCount(5));\r
1217         Assert.AreEqual(0, list.ContainsCount(7));\r
1218         Assert.AreEqual(1, list.ContainsCount(8));\r
1219         list.Add(5);\r
1220         Assert.AreEqual(2, list.ContainsCount(5));\r
1221         Assert.AreEqual(0, list.ContainsCount(7));\r
1222         Assert.AreEqual(1, list.ContainsCount(8));\r
1223       }\r
1224 \r
1225 \r
1226       [Test]\r
1227       public void RemoveAllCopies()\r
1228       {\r
1229         list.Add(5); list.Add(7); list.Add(5);\r
1230         Assert.AreEqual(2, list.ContainsCount(5));\r
1231         Assert.AreEqual(1, list.ContainsCount(7));\r
1232         list.RemoveAllCopies(5);\r
1233         Assert.AreEqual(0, list.ContainsCount(5));\r
1234         Assert.AreEqual(1, list.ContainsCount(7));\r
1235         list.Add(5); list.Add(8); list.Add(5);\r
1236         list.RemoveAllCopies(8);\r
1237         Assert.IsTrue(IC.eq(list, 7, 5, 5));\r
1238       }\r
1239 \r
1240 \r
1241       [Test]\r
1242       public void FindAll()\r
1243       {\r
1244         Fun<int, bool> f = delegate(int i) { return i % 2 == 0; };\r
1245 \r
1246         Assert.IsTrue(list.FindAll(f).IsEmpty);\r
1247         list.Add(5); list.Add(8); list.Add(5); list.Add(10); list.Add(8);\r
1248         Assert.IsTrue(((ArrayList<int>)list.FindAll(f)).Check());\r
1249         Assert.IsTrue(IC.eq(list.FindAll(f), 8, 10, 8));\r
1250       }\r
1251 \r
1252 \r
1253       [Test]\r
1254       public void ContainsAll()\r
1255       {\r
1256         ArrayList<int> list2 = new ArrayList<int>();\r
1257 \r
1258         Assert.IsTrue(list.ContainsAll(list2));\r
1259         list2.Add(4);\r
1260         Assert.IsFalse(list.ContainsAll(list2));\r
1261         list.Add(4);\r
1262         Assert.IsTrue(list.ContainsAll(list2));\r
1263         list.Add(5);\r
1264         Assert.IsTrue(list.ContainsAll(list2));\r
1265         list2.Add(4);\r
1266         Assert.IsFalse(list.ContainsAll(list2));\r
1267         list.Add(4);\r
1268         Assert.IsTrue(list.ContainsAll(list2));\r
1269       }\r
1270 \r
1271 \r
1272       [Test]\r
1273       public void RetainAll()\r
1274       {\r
1275         ArrayList<int> list2 = new ArrayList<int>();\r
1276 \r
1277         list.Add(4); list.Add(4); list.Add(5); list.Add(4); list.Add(6);\r
1278         list2.Add(5); list2.Add(4); list2.Add(7); list2.Add(7); list2.Add(4);\r
1279         list.RetainAll(list2);\r
1280         Assert.IsTrue(list.Check());\r
1281         Assert.IsTrue(IC.eq(list, 4, 4, 5));\r
1282         list.Add(5); list.Add(4); list.Add(6);\r
1283         list2.Clear();\r
1284         list2.Add(5); list2.Add(5); list2.Add(6);\r
1285         list.RetainAll(list2);\r
1286         Assert.IsTrue(list.Check());\r
1287         Assert.IsTrue(IC.eq(list, 5, 5, 6));\r
1288         list2.Clear();\r
1289         list2.Add(7); list2.Add(8); list2.Add(9);\r
1290         list.RetainAll(list2);\r
1291         Assert.IsTrue(list.Check());\r
1292         Assert.IsTrue(IC.eq(list));\r
1293       }\r
1294 \r
1295 \r
1296       [Test]\r
1297       public void RemoveAll()\r
1298       {\r
1299         ArrayList<int> list2 = new ArrayList<int>();\r
1300 \r
1301         list.Add(4); list.Add(4); list.Add(5); list.Add(4); list.Add(6);\r
1302         list2.Add(5); list2.Add(4); list2.Add(7); list2.Add(7); list2.Add(4);\r
1303         list.RemoveAll(list2);\r
1304         Assert.IsTrue(list.Check());\r
1305         Assert.IsTrue(IC.eq(list, 4, 6));\r
1306         list.Add(5); list.Add(4); list.Add(6);\r
1307         list2.Clear();\r
1308         list2.Add(6); list2.Add(5); list2.Add(5); list2.Add(6);\r
1309         list.RemoveAll(list2);\r
1310         Assert.IsTrue(list.Check());\r
1311         Assert.IsTrue(IC.eq(list, 4, 4));\r
1312         list2.Clear();\r
1313         list2.Add(7); list2.Add(8); list2.Add(9);\r
1314         list.RemoveAll(list2);\r
1315         Assert.IsTrue(list.Check());\r
1316         Assert.IsTrue(IC.eq(list, 4, 4));\r
1317       }\r
1318 \r
1319 \r
1320       [Test]\r
1321       public void Remove()\r
1322       {\r
1323         Assert.IsFalse(list.FIFO);\r
1324         list.Add(4); list.Add(4); list.Add(5); list.Add(4); list.Add(6);\r
1325         Assert.IsFalse(list.Remove(2));\r
1326         Assert.IsTrue(list.Check());\r
1327         Assert.IsTrue(list.Remove(4));\r
1328         Assert.IsTrue(list.Check());\r
1329         Assert.IsTrue(IC.eq(list, 4, 4, 5, 6));\r
1330         Assert.AreEqual(6, list.RemoveLast());\r
1331         Assert.IsTrue(list.Check());\r
1332         Assert.IsTrue(IC.eq(list, 4, 4, 5));\r
1333         list.Add(7);\r
1334         Assert.AreEqual(4, list.RemoveFirst());\r
1335         Assert.IsTrue(list.Check());\r
1336         Assert.IsTrue(IC.eq(list, 4, 5, 7));\r
1337 \r
1338         list.FIFO = true;\r
1339         list.Clear();\r
1340         list.Add(4); list.Add(4); list.Add(5); list.Add(4); list.Add(6);\r
1341         Assert.IsFalse(list.Remove(2));\r
1342         Assert.IsTrue(list.Check());\r
1343         Assert.IsTrue(list.Remove(4));\r
1344         Assert.IsTrue(list.Check());\r
1345         Assert.IsTrue(IC.eq(list, 4, 5, 4, 6));\r
1346         Assert.AreEqual(6, list.RemoveLast());\r
1347         Assert.IsTrue(list.Check());\r
1348         Assert.IsTrue(IC.eq(list, 4, 5, 4));\r
1349         list.Add(7);\r
1350         Assert.AreEqual(4, list.RemoveFirst());\r
1351         Assert.IsTrue(list.Check());\r
1352         Assert.IsTrue(IC.eq(list, 5, 4, 7));\r
1353       }\r
1354 \r
1355 \r
1356       [Test]\r
1357       public void Clear()\r
1358       {\r
1359         list.Add(7); list.Add(7);\r
1360         list.Clear();\r
1361         Assert.IsTrue(list.IsEmpty);\r
1362       }\r
1363 \r
1364 \r
1365       [TearDown]\r
1366       public void Dispose() { list = null; }\r
1367     }\r
1368   }\r
1369 \r
1370 \r
1371 \r
1372 \r
1373   namespace Indexed\r
1374   {\r
1375     [TestFixture]\r
1376     public class Searching\r
1377     {\r
1378       private IIndexed<int> dit;\r
1379 \r
1380 \r
1381       [SetUp]\r
1382       public void Init()\r
1383       {\r
1384         dit = new ArrayList<int>();\r
1385       }\r
1386 \r
1387 \r
1388       [Test]\r
1389       public void IndexOf()\r
1390       {\r
1391         Assert.AreEqual(~0, dit.IndexOf(6));\r
1392         dit.Add(7);\r
1393         Assert.AreEqual(~1, dit.IndexOf(6));\r
1394         Assert.AreEqual(~1, dit.LastIndexOf(6));\r
1395         Assert.AreEqual(0, dit.IndexOf(7));\r
1396         dit.Add(5); dit.Add(7); dit.Add(8); dit.Add(7);\r
1397         Assert.AreEqual(~5, dit.IndexOf(6));\r
1398         Assert.AreEqual(0, dit.IndexOf(7));\r
1399         Assert.AreEqual(4, dit.LastIndexOf(7));\r
1400         Assert.AreEqual(3, dit.IndexOf(8));\r
1401         Assert.AreEqual(1, dit.LastIndexOf(5));\r
1402       }\r
1403 \r
1404 \r
1405       [TearDown]\r
1406       public void Dispose()\r
1407       {\r
1408         dit = null;\r
1409       }\r
1410     }\r
1411 \r
1412 \r
1413 \r
1414     [TestFixture]\r
1415     public class Removing\r
1416     {\r
1417       private IIndexed<int> dit;\r
1418 \r
1419 \r
1420       [SetUp]\r
1421       public void Init()\r
1422       {\r
1423         dit = new ArrayList<int>();\r
1424       }\r
1425 \r
1426 \r
1427       [Test]\r
1428       public void RemoveAt()\r
1429       {\r
1430         dit.Add(5); dit.Add(7); dit.Add(9); dit.Add(1); dit.Add(2);\r
1431         Assert.AreEqual(7, dit.RemoveAt(1));\r
1432         Assert.IsTrue(((ArrayList<int>)dit).Check());\r
1433         Assert.IsTrue(IC.eq(dit, 5, 9, 1, 2));\r
1434         Assert.AreEqual(5, dit.RemoveAt(0));\r
1435         Assert.IsTrue(((ArrayList<int>)dit).Check());\r
1436         Assert.IsTrue(IC.eq(dit, 9, 1, 2));\r
1437         Assert.AreEqual(2, dit.RemoveAt(2));\r
1438         Assert.IsTrue(((ArrayList<int>)dit).Check());\r
1439         Assert.IsTrue(IC.eq(dit, 9, 1));\r
1440       }\r
1441 \r
1442 \r
1443       [Test]\r
1444       [ExpectedException(typeof(IndexOutOfRangeException))]\r
1445       public void RemoveAtBad0()\r
1446       {\r
1447         dit.RemoveAt(0);\r
1448       }\r
1449 \r
1450 \r
1451       [Test]\r
1452       [ExpectedException(typeof(IndexOutOfRangeException))]\r
1453       public void RemoveAtBadM1()\r
1454       {\r
1455         dit.RemoveAt(-1);\r
1456       }\r
1457 \r
1458 \r
1459       [Test]\r
1460       [ExpectedException(typeof(IndexOutOfRangeException))]\r
1461       public void RemoveAtBad1()\r
1462       {\r
1463         dit.Add(8);\r
1464         dit.RemoveAt(1);\r
1465       }\r
1466 \r
1467 \r
1468       [Test]\r
1469       public void RemoveInterval()\r
1470       {\r
1471         dit.RemoveInterval(0, 0);\r
1472         dit.Add(10); dit.Add(20); dit.Add(30); dit.Add(40); dit.Add(50); dit.Add(60);\r
1473         dit.RemoveInterval(3, 0);\r
1474         Assert.IsTrue(((ArrayList<int>)dit).Check());\r
1475         Assert.IsTrue(IC.eq(dit, 10, 20, 30, 40, 50, 60));\r
1476         dit.RemoveInterval(3, 1);\r
1477         Assert.IsTrue(((ArrayList<int>)dit).Check());\r
1478         Assert.IsTrue(IC.eq(dit, 10, 20, 30, 50, 60));\r
1479         dit.RemoveInterval(1, 3);\r
1480         Assert.IsTrue(((ArrayList<int>)dit).Check());\r
1481         Assert.IsTrue(IC.eq(dit, 10, 60));\r
1482         dit.RemoveInterval(0, 2);\r
1483         Assert.IsTrue(((ArrayList<int>)dit).Check());\r
1484         Assert.IsTrue(IC.eq(dit));\r
1485         dit.Add(10); dit.Add(20); dit.Add(30); dit.Add(40); dit.Add(50); dit.Add(60);\r
1486         dit.RemoveInterval(0, 2);\r
1487         Assert.IsTrue(((ArrayList<int>)dit).Check());\r
1488         Assert.IsTrue(IC.eq(dit, 30, 40, 50, 60));\r
1489         dit.RemoveInterval(2, 2);\r
1490         Assert.IsTrue(((ArrayList<int>)dit).Check());\r
1491         Assert.IsTrue(IC.eq(dit, 30, 40));\r
1492       }\r
1493 \r
1494 \r
1495       [TearDown]\r
1496       public void Dispose()\r
1497       {\r
1498         dit = null;\r
1499       }\r
1500     }\r
1501   }\r
1502 \r
1503 \r
1504 \r
1505 \r
1506   namespace List\r
1507   {\r
1508     [TestFixture]\r
1509     public class Searching\r
1510     {\r
1511       private IList<int> lst;\r
1512 \r
1513 \r
1514       [SetUp]\r
1515       public void Init() { lst = new ArrayList<int>(); }\r
1516 \r
1517 \r
1518       [TearDown]\r
1519       public void Dispose() { lst = null; }\r
1520 \r
1521 \r
1522       [Test]\r
1523       [ExpectedException(typeof(NoSuchItemException))]\r
1524       public void FirstBad()\r
1525       {\r
1526         int f = lst.First;\r
1527       }\r
1528 \r
1529 \r
1530       [Test]\r
1531       [ExpectedException(typeof(NoSuchItemException))]\r
1532       public void LastBad()\r
1533       {\r
1534         int f = lst.Last;\r
1535       }\r
1536 \r
1537 \r
1538       [Test]\r
1539       public void FirstLast()\r
1540       {\r
1541         lst.Add(19);\r
1542         Assert.AreEqual(19, lst.First);\r
1543         Assert.AreEqual(19, lst.Last);\r
1544         lst.Add(34); lst.InsertFirst(12);\r
1545         Assert.AreEqual(12, lst.First);\r
1546         Assert.AreEqual(34, lst.Last);\r
1547       }\r
1548 \r
1549 \r
1550       [Test]\r
1551       public void This()\r
1552       {\r
1553         lst.Add(34);\r
1554         Assert.AreEqual(34, lst[0]);\r
1555         lst[0] = 56;\r
1556         Assert.AreEqual(56, lst.First);\r
1557         lst.Add(7); lst.Add(7); lst.Add(7); lst.Add(7);\r
1558         lst[0] = 45; lst[2] = 78; lst[4] = 101;\r
1559         Assert.IsTrue(IC.eq(lst, 45, 7, 78, 7, 101));\r
1560       }\r
1561 \r
1562 \r
1563       [Test]\r
1564       [ExpectedException(typeof(IndexOutOfRangeException))]\r
1565       public void ThisBadEmptyGet()\r
1566       {\r
1567         int f = lst[0];\r
1568       }\r
1569 \r
1570 \r
1571       [Test]\r
1572       [ExpectedException(typeof(IndexOutOfRangeException))]\r
1573       public void ThisBadLowGet()\r
1574       {\r
1575         lst.Add(7);\r
1576 \r
1577         int f = lst[-1];\r
1578       }\r
1579 \r
1580 \r
1581       [Test]\r
1582       [ExpectedException(typeof(IndexOutOfRangeException))]\r
1583       public void ThisBadHiGet()\r
1584       {\r
1585         lst.Add(6);\r
1586 \r
1587         int f = lst[1];\r
1588       }\r
1589 \r
1590 \r
1591       [Test]\r
1592       [ExpectedException(typeof(IndexOutOfRangeException))]\r
1593       public void ThisBadEmptySet()\r
1594       {\r
1595         lst[0] = 4;\r
1596       }\r
1597 \r
1598 \r
1599       [Test]\r
1600       [ExpectedException(typeof(IndexOutOfRangeException))]\r
1601       public void ThisBadLowSet()\r
1602       {\r
1603         lst.Add(7);\r
1604         lst[-1] = 9;\r
1605       }\r
1606 \r
1607 \r
1608       [Test]\r
1609       [ExpectedException(typeof(IndexOutOfRangeException))]\r
1610       public void ThisBadHiSet()\r
1611       {\r
1612         lst.Add(6);\r
1613         lst[1] = 11;\r
1614       }\r
1615     }\r
1616 \r
1617 \r
1618 \r
1619     [TestFixture]\r
1620     public class Inserting\r
1621     {\r
1622       private IList<int> lst;\r
1623 \r
1624 \r
1625       [SetUp]\r
1626       public void Init() { lst = new ArrayList<int>(); }\r
1627 \r
1628 \r
1629       [TearDown]\r
1630       public void Dispose() { lst = null; }\r
1631 \r
1632 \r
1633       [Test]\r
1634       public void Insert()\r
1635       {\r
1636         lst.Insert(0, 5);\r
1637         Assert.IsTrue(IC.eq(lst, 5));\r
1638         lst.Insert(0, 7);\r
1639         Assert.IsTrue(IC.eq(lst, 7, 5));\r
1640         lst.Insert(1, 4);\r
1641         Assert.IsTrue(IC.eq(lst, 7, 4, 5));\r
1642         lst.Insert(3, 2);\r
1643         Assert.IsTrue(IC.eq(lst, 7, 4, 5, 2));\r
1644       }\r
1645 \r
1646       [Test]\r
1647       public void InsertDuplicate()\r
1648       {\r
1649         lst.Insert(0, 5);\r
1650         Assert.IsTrue(IC.eq(lst, 5));\r
1651         lst.Insert(0, 7);\r
1652         Assert.IsTrue(IC.eq(lst, 7, 5));\r
1653         lst.Insert(1, 5);\r
1654         Assert.IsTrue(IC.eq(lst, 7, 5, 5));\r
1655       }\r
1656 \r
1657 \r
1658       [Test]\r
1659       public void InsertAllDuplicate1()\r
1660       {\r
1661         lst.Insert(0, 3);\r
1662         Assert.IsTrue(IC.eq(lst, 3));\r
1663         lst.Insert(0, 7);\r
1664         Assert.IsTrue(IC.eq(lst, 7, 3));\r
1665         lst.InsertAll<int>(1, new int[] { 1, 2, 3, 4 });\r
1666         Assert.IsTrue(IC.eq(lst, 7, 1, 2, 3, 4, 3));\r
1667         Assert.IsTrue(lst.Check());\r
1668       }\r
1669       [Test]\r
1670       public void InsertAllDuplicate2()\r
1671       {\r
1672         lst.Insert(0, 3);\r
1673         Assert.IsTrue(IC.eq(lst, 3));\r
1674         lst.Insert(0, 7);\r
1675         Assert.IsTrue(IC.eq(lst, 7, 3));\r
1676         lst.InsertAll<int>(1, new int[] { 5, 6, 5, 8 });\r
1677         Assert.IsTrue(lst.Check());\r
1678         Assert.IsTrue(IC.eq(lst, 7, 5, 6, 5, 8, 3));\r
1679       }\r
1680 \r
1681 \r
1682       [Test]\r
1683       [ExpectedException(typeof(IndexOutOfRangeException))]\r
1684       public void BadInsertLow()\r
1685       {\r
1686         lst.Add(7);\r
1687         lst.Insert(-1, 9);\r
1688       }\r
1689 \r
1690 \r
1691       [Test]\r
1692       [ExpectedException(typeof(IndexOutOfRangeException))]\r
1693       public void BadInsertHi()\r
1694       {\r
1695         lst.Add(6);\r
1696         lst.Insert(2, 11);\r
1697       }\r
1698 \r
1699 \r
1700       [Test]\r
1701       public void FIFO()\r
1702       {\r
1703         for (int i = 0; i < 7; i++)\r
1704           lst.Add(2 * i);\r
1705 \r
1706         Assert.IsFalse(lst.FIFO);\r
1707         Assert.AreEqual(12, lst.Remove());\r
1708         Assert.AreEqual(10, lst.Remove());\r
1709         lst.FIFO = true;\r
1710         Assert.AreEqual(0, lst.Remove());\r
1711         Assert.AreEqual(2, lst.Remove());\r
1712         lst.FIFO = false;\r
1713         Assert.AreEqual(8, lst.Remove());\r
1714         Assert.AreEqual(6, lst.Remove());\r
1715       }\r
1716 \r
1717 \r
1718       [Test]\r
1719       public void InsertFirstLast()\r
1720       {\r
1721         lst.InsertFirst(4);\r
1722         lst.InsertLast(5);\r
1723         lst.InsertFirst(14);\r
1724         lst.InsertLast(15);\r
1725         lst.InsertFirst(24);\r
1726         lst.InsertLast(25);\r
1727         lst.InsertFirst(34);\r
1728         lst.InsertLast(55);\r
1729         Assert.IsTrue(IC.eq(lst, 34, 24, 14, 4, 5, 15, 25, 55));\r
1730       }\r
1731 \r
1732 \r
1733       [Test]\r
1734       public void InsertFirst()\r
1735       {\r
1736         lst.Add(2);\r
1737         lst.Add(3);\r
1738         lst.Add(2);\r
1739         lst.Add(5);\r
1740         lst.ViewOf(2).InsertFirst(7);\r
1741         Assert.IsTrue(lst.Check());\r
1742         Assert.IsTrue(IC.eq(lst, 7, 2, 3, 2, 5));\r
1743         lst.ViewOf(3).InsertFirst(8);\r
1744         Assert.IsTrue(lst.Check());\r
1745         Assert.IsTrue(IC.eq(lst, 7, 2, 8, 3, 2, 5));\r
1746         lst.ViewOf(5).InsertFirst(9);\r
1747         Assert.IsTrue(lst.Check());\r
1748         Assert.IsTrue(IC.eq(lst, 7, 2, 8, 3, 2, 9, 5));\r
1749       }\r
1750 \r
1751       [Test]\r
1752       public void InsertAfter()\r
1753       {\r
1754         lst.Add(1);\r
1755         lst.Add(2);\r
1756         lst.Add(3);\r
1757         lst.Add(2);\r
1758         lst.Add(5);\r
1759         lst.LastViewOf(2).InsertLast(7);\r
1760         Assert.IsTrue(lst.Check());\r
1761         Assert.IsTrue(IC.eq(lst, 1, 2, 3, 2, 7, 5));\r
1762         lst.LastViewOf(1).InsertLast(8);\r
1763         Assert.IsTrue(lst.Check());\r
1764         Assert.IsTrue(IC.eq(lst, 1, 8, 2, 3, 2, 7, 5));\r
1765         lst.LastViewOf(5).InsertLast(9);\r
1766         Assert.IsTrue(lst.Check());\r
1767         Assert.IsTrue(IC.eq(lst, 1, 8, 2, 3, 2, 7, 5, 9));\r
1768       }\r
1769 \r
1770       [Test]\r
1771       public void InsertAll()\r
1772       {\r
1773         lst.Add(1);\r
1774         lst.Add(2);\r
1775         lst.Add(3);\r
1776         lst.Add(4);\r
1777 \r
1778         IList<int> lst2 = new ArrayList<int>();\r
1779 \r
1780         lst2.Add(7); lst2.Add(8); lst2.Add(9);\r
1781         lst.InsertAll(0, lst2);\r
1782         Assert.IsTrue(lst.Check());\r
1783         Assert.IsTrue(IC.eq(lst, 7, 8, 9, 1, 2, 3, 4));\r
1784         lst.InsertAll(7, lst2);\r
1785         Assert.IsTrue(lst.Check());\r
1786         Assert.IsTrue(IC.eq(lst, 7, 8, 9, 1, 2, 3, 4, 7, 8, 9));\r
1787         lst.InsertAll(5, lst2);\r
1788         Assert.IsTrue(lst.Check());\r
1789         Assert.IsTrue(IC.eq(lst, 7, 8, 9, 1, 2, 7, 8, 9, 3, 4, 7, 8, 9));\r
1790       }\r
1791 \r
1792 \r
1793       [Test]\r
1794       public void Map()\r
1795       {\r
1796         Fun<int, string> m = delegate(int i) { return "<<" + i + ">>"; };\r
1797         IList<string> r = lst.Map(m);\r
1798 \r
1799         Assert.IsTrue(r.Check());\r
1800         Assert.IsTrue(r.IsEmpty);\r
1801         lst.Add(1);\r
1802         lst.Add(2);\r
1803         lst.Add(3);\r
1804         lst.Add(4);\r
1805         r = lst.Map(m);\r
1806         Assert.IsTrue(r.Check());\r
1807         Assert.AreEqual(4, r.Count);\r
1808         for (int i = 0; i < 4; i++)\r
1809           Assert.AreEqual("<<" + (i + 1) + ">>", r[i]);\r
1810       }\r
1811 \r
1812       [Test]\r
1813       [ExpectedException(typeof(CollectionModifiedException))]\r
1814       public void BadMapper()\r
1815       {\r
1816         lst.Add(1);\r
1817         lst.Add(2);\r
1818         lst.Add(3);\r
1819         Fun<int, bool> m = delegate(int i) { if (i == 2) lst.Add(7); return true; };\r
1820         lst.Map(m);\r
1821       }\r
1822 \r
1823       [Test]\r
1824       [ExpectedException(typeof(CollectionModifiedException))]\r
1825       public void ModifyingFindAll()\r
1826       {\r
1827         lst.Add(1);\r
1828         lst.Add(2);\r
1829         lst.Add(3);\r
1830         Fun<int, bool> m = delegate(int i) { if (i == 2) lst.Add(7); return true; };\r
1831         lst.FindAll(m);\r
1832       }\r
1833 \r
1834       [Test]\r
1835       [ExpectedException(typeof(CollectionModifiedException))]\r
1836       public void BadMapperView()\r
1837       {\r
1838         lst = lst.View(0, 0);\r
1839         lst.Add(1);\r
1840         lst.Add(2);\r
1841         lst.Add(3);\r
1842         Fun<int, bool> m = delegate(int i) { if (i == 2) lst.Add(7); return true; };\r
1843         lst.Map(m);\r
1844       }\r
1845 \r
1846       [Test]\r
1847       [ExpectedException(typeof(CollectionModifiedException))]\r
1848       public void ModifyingFindAllView()\r
1849       {\r
1850         lst = lst.View(0, 0);\r
1851         lst.Add(1);\r
1852         lst.Add(2);\r
1853         lst.Add(3);\r
1854         Fun<int, bool> m = delegate(int i) { if (i == 2) lst.Add(7); return true; };\r
1855         lst.FindAll(m);\r
1856       }\r
1857 \r
1858       [Test]\r
1859       [ExpectedException(typeof(NoSuchItemException))]\r
1860       public void BadRemove() { lst.Remove(); }\r
1861 \r
1862       [Test]\r
1863       [ExpectedException(typeof(NoSuchItemException))]\r
1864       public void BadRemoveFirst() { lst.RemoveFirst(); }\r
1865 \r
1866       [Test]\r
1867       [ExpectedException(typeof(NoSuchItemException))]\r
1868       public void BadRemoveLast() { lst.RemoveLast(); }\r
1869 \r
1870 \r
1871       [Test]\r
1872       public void RemoveFirstLast()\r
1873       {\r
1874         lst.Add(1);\r
1875         lst.Add(2);\r
1876         lst.Add(3);\r
1877         lst.Add(4);\r
1878         Assert.AreEqual(1, lst.RemoveFirst());\r
1879         Assert.AreEqual(4, lst.RemoveLast());\r
1880         Assert.AreEqual(2, lst.RemoveFirst());\r
1881         Assert.AreEqual(3, lst.RemoveLast());\r
1882         Assert.IsTrue(lst.IsEmpty);\r
1883       }\r
1884 \r
1885 \r
1886       [Test]\r
1887       public void Reverse()\r
1888       {\r
1889         for (int i = 0; i < 10; i++)\r
1890           lst.Add(i);\r
1891 \r
1892         lst.Reverse();\r
1893         Assert.IsTrue(lst.Check());\r
1894         Assert.IsTrue(IC.eq(lst, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0));\r
1895         lst.View(0, 3).Reverse();\r
1896         Assert.IsTrue(lst.Check());\r
1897         Assert.IsTrue(IC.eq(lst, 7, 8, 9, 6, 5, 4, 3, 2, 1, 0));\r
1898         lst.View(7, 0).Reverse();\r
1899         Assert.IsTrue(lst.Check());\r
1900         Assert.IsTrue(IC.eq(lst, 7, 8, 9, 6, 5, 4, 3, 2, 1, 0));\r
1901         lst.View(7, 3).Reverse();\r
1902         Assert.IsTrue(lst.Check());\r
1903         Assert.IsTrue(IC.eq(lst, 7, 8, 9, 6, 5, 4, 3, 0, 1, 2));\r
1904         lst.View(5, 1).Reverse();\r
1905         Assert.IsTrue(lst.Check());\r
1906         Assert.IsTrue(IC.eq(lst, 7, 8, 9, 6, 5, 4, 3, 0, 1, 2));\r
1907       }\r
1908 \r
1909 \r
1910       [Test]\r
1911       [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
1912       public void BadReverse()\r
1913       {\r
1914         for (int i = 0; i < 10; i++)\r
1915           lst.Add(i);\r
1916 \r
1917         lst.View(8, 3).Reverse();\r
1918       }\r
1919     }\r
1920 \r
1921     [TestFixture]\r
1922     public class Combined\r
1923     {\r
1924       private IList<KeyValuePair<int, int>> lst;\r
1925 \r
1926 \r
1927       [SetUp]\r
1928       public void Init()\r
1929       {\r
1930         lst = new ArrayList<KeyValuePair<int, int>>(new KeyValuePairEqualityComparer<int, int>());\r
1931         for (int i = 0; i < 10; i++)\r
1932           lst.Add(new KeyValuePair<int, int>(i, i + 30));\r
1933       }\r
1934 \r
1935 \r
1936       [TearDown]\r
1937       public void Dispose() { lst = null; }\r
1938 \r
1939 \r
1940       [Test]\r
1941       public void Find()\r
1942       {\r
1943         KeyValuePair<int, int> p = new KeyValuePair<int, int>(3, 78);\r
1944         Assert.IsTrue(lst.Find(ref p));\r
1945         Assert.AreEqual(3, p.Key);\r
1946         Assert.AreEqual(33, p.Value);\r
1947         p = new KeyValuePair<int, int>(13, 78);\r
1948         Assert.IsFalse(lst.Find(ref p));\r
1949       }\r
1950 \r
1951 \r
1952       [Test]\r
1953       public void FindOrAdd()\r
1954       {\r
1955         KeyValuePair<int, int> p = new KeyValuePair<int, int>(3, 78);\r
1956 \r
1957         Assert.IsTrue(lst.FindOrAdd(ref p));\r
1958         Assert.AreEqual(3, p.Key);\r
1959         Assert.AreEqual(33, p.Value);\r
1960         p = new KeyValuePair<int, int>(13, 79);\r
1961         Assert.IsFalse(lst.FindOrAdd(ref p));\r
1962         Assert.AreEqual(13, lst[10].Key);\r
1963         Assert.AreEqual(79, lst[10].Value);\r
1964       }\r
1965 \r
1966 \r
1967       [Test]\r
1968       public void Update()\r
1969       {\r
1970         KeyValuePair<int, int> p = new KeyValuePair<int, int>(3, 78);\r
1971 \r
1972         Assert.IsTrue(lst.Update(p));\r
1973         Assert.AreEqual(3, lst[3].Key);\r
1974         Assert.AreEqual(78, lst[3].Value);\r
1975         p = new KeyValuePair<int, int>(13, 78);\r
1976         Assert.IsFalse(lst.Update(p));\r
1977       }\r
1978 \r
1979 \r
1980       [Test]\r
1981       public void UpdateOrAdd()\r
1982       {\r
1983         KeyValuePair<int, int> p = new KeyValuePair<int, int>(3, 78);\r
1984 \r
1985         Assert.IsTrue(lst.UpdateOrAdd(p));\r
1986         Assert.AreEqual(3, lst[3].Key);\r
1987         Assert.AreEqual(78, lst[3].Value);\r
1988         p = new KeyValuePair<int, int>(13, 79);\r
1989         Assert.IsFalse(lst.UpdateOrAdd(p));\r
1990         Assert.AreEqual(13, lst[10].Key);\r
1991         Assert.AreEqual(79, lst[10].Value);\r
1992       }\r
1993 \r
1994 \r
1995       [Test]\r
1996       public void RemoveWithReturn()\r
1997       {\r
1998         KeyValuePair<int, int> p = new KeyValuePair<int, int>(3, 78);\r
1999 \r
2000         Assert.IsTrue(lst.Remove(p, out p));\r
2001         Assert.AreEqual(3, p.Key);\r
2002         Assert.AreEqual(33, p.Value);\r
2003         Assert.AreEqual(4, lst[3].Key);\r
2004         Assert.AreEqual(34, lst[3].Value);\r
2005         p = new KeyValuePair<int, int>(13, 78);\r
2006         Assert.IsFalse(lst.Remove(p, out p));\r
2007       }\r
2008     }\r
2009 \r
2010 \r
2011     [TestFixture]\r
2012     public class SortingTests\r
2013     {\r
2014       private IList<int> lst;\r
2015 \r
2016 \r
2017       [SetUp]\r
2018       public void Init() { lst = new ArrayList<int>(); }\r
2019 \r
2020 \r
2021       [TearDown]\r
2022       public void Dispose() { lst = null; }\r
2023 \r
2024 \r
2025       [Test]\r
2026       public void Sort()\r
2027       {\r
2028         lst.Add(5); lst.Add(6); lst.Add(5); lst.Add(7); lst.Add(3);\r
2029         Assert.IsFalse(lst.IsSorted(new IC()));\r
2030         lst.Sort(new IC());\r
2031         Assert.IsTrue(lst.IsSorted());\r
2032         Assert.IsTrue(lst.IsSorted(new IC()));\r
2033         Assert.IsTrue(IC.eq(lst, 3, 5, 5, 6, 7));\r
2034       }\r
2035 \r
2036 \r
2037       [Test]\r
2038       public void Stability()\r
2039       {\r
2040         IList<KeyValuePair<int, string>> lst2 = new ArrayList<KeyValuePair<int, string>>();\r
2041         SCG.IComparer<KeyValuePair<int, string>> c = new KeyValuePairComparer<int, string>(new IC());\r
2042 \r
2043         lst2.Add(new KeyValuePair<int, string>(5, "a"));\r
2044         lst2.Add(new KeyValuePair<int, string>(5, "b"));\r
2045         lst2.Add(new KeyValuePair<int, string>(6, "c"));\r
2046         lst2.Add(new KeyValuePair<int, string>(4, "d"));\r
2047         lst2.Add(new KeyValuePair<int, string>(3, "e"));\r
2048         lst2.Add(new KeyValuePair<int, string>(4, "f"));\r
2049         lst2.Add(new KeyValuePair<int, string>(5, "handle"));\r
2050         Assert.IsFalse(lst2.IsSorted(c));\r
2051         lst2.Sort(c);\r
2052         Assert.IsTrue(lst2.IsSorted(c));\r
2053 \r
2054         KeyValuePair<int, string> p = lst2.RemoveFirst();\r
2055 \r
2056         Assert.AreEqual(3, p.Key);\r
2057         Assert.AreEqual("e", p.Value);\r
2058         p = lst2.RemoveFirst();\r
2059         Assert.AreEqual(4, p.Key);\r
2060         Assert.AreEqual("d", p.Value);\r
2061         p = lst2.RemoveFirst();\r
2062         Assert.AreEqual(4, p.Key);\r
2063         Assert.AreEqual("f", p.Value);\r
2064         p = lst2.RemoveFirst();\r
2065         Assert.AreEqual(5, p.Key);\r
2066         Assert.AreEqual("a", p.Value);\r
2067         p = lst2.RemoveFirst();\r
2068         Assert.AreEqual(5, p.Key);\r
2069         Assert.AreEqual("b", p.Value);\r
2070         p = lst2.RemoveFirst();\r
2071         Assert.AreEqual(5, p.Key);\r
2072         Assert.AreEqual("handle", p.Value);\r
2073         p = lst2.RemoveFirst();\r
2074         Assert.AreEqual(6, p.Key);\r
2075         Assert.AreEqual("c", p.Value);\r
2076         Assert.IsTrue(lst2.IsEmpty);\r
2077       }\r
2078     }\r
2079 \r
2080     [TestFixture]\r
2081     public class ShuffleTests\r
2082     {\r
2083       private IList<int> lst;\r
2084 \r
2085 \r
2086       [SetUp]\r
2087       public void Init() { lst = new ArrayList<int>(); }\r
2088 \r
2089 \r
2090       [TearDown]\r
2091       public void Dispose() { lst = null; }\r
2092 \r
2093 \r
2094       [Test]\r
2095       public void Shuffle()\r
2096       {\r
2097         lst.Add(5); lst.Add(6); lst.Add(5); lst.Add(7); lst.Add(3);\r
2098         for (int i = 0; i < 100; i++)\r
2099         {\r
2100           lst.Shuffle(new C5Random(i + 1));\r
2101           Assert.IsTrue(lst.Check(), "Check " + i);\r
2102           int[] lst2 = lst.ToArray();\r
2103           Sorting.IntroSort<int>(lst2);\r
2104           Assert.IsTrue(IC.eq(lst2, 3, 5, 5, 6, 7), "Contents " + i);\r
2105         }\r
2106       }\r
2107     }\r
2108 \r
2109   }\r
2110 \r
2111 \r
2112   namespace IStackQueue\r
2113   {\r
2114     [TestFixture]\r
2115     public class Stack\r
2116     {\r
2117       private IStack<int> list;\r
2118 \r
2119 \r
2120       [SetUp]\r
2121       public void Init() { list = new ArrayList<int>(); }\r
2122 \r
2123 \r
2124       [Test]\r
2125       public void Normal()\r
2126       {\r
2127         list.Push(7);\r
2128         list.Push(5);\r
2129         list.Push(7);\r
2130         list.Push(8);\r
2131         list.Push(9);\r
2132         Assert.AreEqual(9, list.Pop());\r
2133         Assert.AreEqual(8, list.Pop());\r
2134         Assert.AreEqual(7, list.Pop());\r
2135         Assert.AreEqual(5, list.Pop());\r
2136         Assert.AreEqual(7, list.Pop());\r
2137       }\r
2138 \r
2139 \r
2140       [Test]\r
2141       [ExpectedException(typeof(NoSuchItemException))]\r
2142       public void PopEmpty()\r
2143       {\r
2144         list.Push(5);\r
2145         Assert.AreEqual(5, list.Pop());\r
2146         list.Pop();\r
2147       }\r
2148 \r
2149 \r
2150       [TearDown]\r
2151       public void Dispose() { list = null; }\r
2152     }\r
2153     [TestFixture]\r
2154     public class Queue\r
2155     {\r
2156       private IQueue<int> list;\r
2157 \r
2158 \r
2159       [SetUp]\r
2160       public void Init() { list = new ArrayList<int>(); }\r
2161 \r
2162 \r
2163       [Test]\r
2164       public void Normal()\r
2165       {\r
2166         list.Enqueue(7);\r
2167         list.Enqueue(5);\r
2168         list.Enqueue(7);\r
2169         list.Enqueue(8);\r
2170         list.Enqueue(9);\r
2171         Assert.AreEqual(7, list.Dequeue());\r
2172         Assert.AreEqual(5, list.Dequeue());\r
2173         Assert.AreEqual(7, list.Dequeue());\r
2174         Assert.AreEqual(8, list.Dequeue());\r
2175         Assert.AreEqual(9, list.Dequeue());\r
2176       }\r
2177 \r
2178 \r
2179       [Test]\r
2180       [ExpectedException(typeof(NoSuchItemException))]\r
2181       public void DeQueueEmpty()\r
2182       {\r
2183         list.Enqueue(5);\r
2184         Assert.AreEqual(5, list.Dequeue());\r
2185         list.Dequeue();\r
2186       }\r
2187 \r
2188 \r
2189       [TearDown]\r
2190       public void Dispose() { list = null; }\r
2191     }\r
2192   }\r
2193 \r
2194 \r
2195   namespace Range\r
2196   {\r
2197     [TestFixture]\r
2198     public class Range\r
2199     {\r
2200       private IList<int> lst;\r
2201 \r
2202 \r
2203       [SetUp]\r
2204       public void Init() { lst = new ArrayList<int>(); }\r
2205 \r
2206 \r
2207       [TearDown]\r
2208       public void Dispose() { lst = null; }\r
2209 \r
2210 \r
2211       [Test]\r
2212       public void GetRange()\r
2213       {\r
2214         //Assert.IsTrue(IC.eq(lst[0, 0)));\r
2215         for (int i = 0; i < 10; i++) lst.Add(i);\r
2216 \r
2217         Assert.IsTrue(IC.eq(lst[0, 3], 0, 1, 2));\r
2218         Assert.IsTrue(IC.eq(lst[3, 4], 3, 4, 5, 6));\r
2219         Assert.IsTrue(IC.eq(lst[6, 4], 6, 7, 8, 9));\r
2220       }\r
2221 \r
2222 \r
2223       [Test]\r
2224       [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
2225       public void BadGetRange()\r
2226       {\r
2227         object foo = lst[0, 11];\r
2228       }\r
2229 \r
2230 \r
2231       [Test]\r
2232       public void Backwards()\r
2233       {\r
2234         for (int i = 0; i < 10; i++) lst.Add(i);\r
2235 \r
2236         Assert.IsTrue(IC.eq(lst.Backwards(), 9, 8, 7, 6, 5, 4, 3, 2, 1, 0));\r
2237         Assert.IsTrue(IC.eq(lst[0, 4].Backwards(), 3, 2, 1, 0));\r
2238         Assert.IsTrue(IC.eq(lst[3, 4].Backwards(), 6, 5, 4, 3));\r
2239         Assert.IsTrue(IC.eq(lst[6, 4].Backwards(), 9, 8, 7, 6));\r
2240       }\r
2241 \r
2242 \r
2243       [Test]\r
2244       public void DirectionAndCount()\r
2245       {\r
2246         for (int i = 0; i < 10; i++) lst.Add(i);\r
2247 \r
2248         Assert.AreEqual(EnumerationDirection.Forwards, lst.Direction);\r
2249         Assert.AreEqual(EnumerationDirection.Forwards, lst[3, 4].Direction);\r
2250         Assert.AreEqual(EnumerationDirection.Backwards, lst[3, 4].Backwards().Direction);\r
2251         Assert.AreEqual(EnumerationDirection.Backwards, lst.Backwards().Direction);\r
2252         Assert.AreEqual(4, lst[3, 4].Count);\r
2253         Assert.AreEqual(4, lst[3, 4].Backwards().Count);\r
2254         Assert.AreEqual(10, lst.Backwards().Count);\r
2255       }\r
2256 \r
2257 \r
2258       [Test]\r
2259       [ExpectedException(typeof(CollectionModifiedException))]\r
2260       public void MoveNextAfterUpdate()\r
2261       {\r
2262         for (int i = 0; i < 10; i++) lst.Add(i);\r
2263 \r
2264         foreach (int i in lst)\r
2265         {\r
2266           lst.Add(45 + i);\r
2267         }\r
2268       }\r
2269     }\r
2270   }\r
2271 \r
2272 \r
2273 \r
2274 \r
2275   namespace View\r
2276   {\r
2277     [TestFixture]\r
2278     public class Simple\r
2279     {\r
2280       ArrayList<int> list, view;\r
2281 \r
2282 \r
2283       [SetUp]\r
2284       public void Init()\r
2285       {\r
2286         list = new ArrayList<int>();\r
2287         list.Add(0); list.Add(1); list.Add(2); list.Add(3);\r
2288         view = (ArrayList<int>)list.View(1, 2);\r
2289       }\r
2290 \r
2291 \r
2292       [TearDown]\r
2293       public void Dispose()\r
2294       {\r
2295         list = view = null;\r
2296       }\r
2297 \r
2298 \r
2299       void check()\r
2300       {\r
2301         Assert.IsTrue(list.Check());\r
2302         Assert.IsTrue(view.Check());\r
2303       }\r
2304 \r
2305 \r
2306       //static void pint(IEnumerable<int> l) { foreach (int cell in l) Console.WriteLine(cell); }\r
2307 \r
2308       [Test]\r
2309       public void InsertPointer()\r
2310       {\r
2311         IList<int> view2 = list.View(2, 0);\r
2312         list.Insert(view2, 7);\r
2313         check();\r
2314         list.Insert(list, 8);\r
2315         check();\r
2316         view.Insert(view2, 9);\r
2317         check();\r
2318         view.Insert(list.View(3, 2), 10);\r
2319         check();\r
2320         view.Insert(list.ViewOf(0), 11);\r
2321         check();\r
2322         Assert.IsTrue(IC.eq(list, 0, 11, 1, 9, 7, 2, 10, 3, 8));\r
2323         Assert.IsTrue(IC.eq(view, 11, 1, 9, 7, 2, 10));\r
2324       }\r
2325 \r
2326       [Test]\r
2327       [ExpectedException(typeof(IndexOutOfRangeException))]\r
2328       public void InsertPointerBad1()\r
2329       {\r
2330         view.Insert(list.View(0, 0), 7);\r
2331       }\r
2332 \r
2333       [Test]\r
2334       [ExpectedException(typeof(IndexOutOfRangeException))]\r
2335       public void InsertPointerBad2()\r
2336       {\r
2337         view.Insert(list, 7);\r
2338       }\r
2339 \r
2340       [Test]\r
2341       [ExpectedException(typeof(IncompatibleViewException))]\r
2342       public void InsertPointerBad3()\r
2343       {\r
2344         list.Insert(new ArrayList<int>(), 7);\r
2345       }\r
2346 \r
2347       [Test]\r
2348       [ExpectedException(typeof(IncompatibleViewException))]\r
2349       public void InsertPointerBad4()\r
2350       {\r
2351         list.Insert(new ArrayList<int>().View(0, 0), 7);\r
2352       }\r
2353 \r
2354 \r
2355       [Test]\r
2356       public void Span()\r
2357       {\r
2358         IList<int> span = list.View(1, 0).Span(list.View(2, 0));\r
2359         Assert.IsTrue(span.Check());\r
2360         Assert.AreEqual(1, span.Offset);\r
2361         Assert.AreEqual(1, span.Count);\r
2362         span = list.View(0, 2).Span(list.View(2, 2));\r
2363         Assert.IsTrue(span.Check());\r
2364         Assert.AreEqual(0, span.Offset);\r
2365         Assert.AreEqual(4, span.Count);\r
2366         span = list.View(3, 1).Span(list.View(1, 1));\r
2367         Assert.IsNull(span);\r
2368       }\r
2369 \r
2370       [Test]\r
2371       public void ViewOf()\r
2372       {\r
2373         for (int i = 0; i < 4; i++)\r
2374           list.Add(i);\r
2375         IList<int> v = view.ViewOf(2);\r
2376         Assert.IsTrue(v.Check());\r
2377         Assert.IsTrue(IC.eq(v, 2));\r
2378         Assert.AreEqual(2, v.Offset);\r
2379         v = list.ViewOf(2);\r
2380         Assert.IsTrue(v.Check());\r
2381         Assert.IsTrue(IC.eq(v, 2));\r
2382         Assert.AreEqual(2, v.Offset);\r
2383         v = list.LastViewOf(2);\r
2384         Assert.IsTrue(v.Check());\r
2385         Assert.IsTrue(IC.eq(v, 2));\r
2386         Assert.AreEqual(6, v.Offset);\r
2387       }\r
2388 \r
2389       [Test]\r
2390       public void ArrayStuff()\r
2391       {\r
2392         Assert.IsTrue(IC.eq(view.ToArray(), 1, 2));\r
2393         int[] extarray = new int[5];\r
2394         view.CopyTo(extarray, 2);\r
2395         Assert.IsTrue(IC.eq(extarray, 0, 0, 1, 2, 0));\r
2396       }\r
2397 \r
2398       [Test]\r
2399       public void BadViewOf()\r
2400       {\r
2401         Assert.IsNull(view.ViewOf(5));\r
2402         Assert.IsNull(view.LastViewOf(5));\r
2403         Assert.IsNull(view.ViewOf(3));\r
2404         Assert.IsNull(view.LastViewOf(3));\r
2405         Assert.IsNull(view.ViewOf(0));\r
2406         Assert.IsNull(view.LastViewOf(0));\r
2407       }\r
2408 \r
2409       [Test]\r
2410       public void Add()\r
2411       {\r
2412         check();\r
2413         Assert.IsTrue(IC.eq(list, 0, 1, 2, 3));\r
2414         Assert.IsTrue(IC.eq(view, 1, 2));\r
2415         view.InsertFirst(10);\r
2416         check();\r
2417         Assert.IsTrue(IC.eq(list, 0, 10, 1, 2, 3));\r
2418         Assert.IsTrue(IC.eq(view, 10, 1, 2));\r
2419         view.Clear();\r
2420         Assert.IsFalse(view.IsReadOnly);\r
2421         Assert.IsTrue(view.AllowsDuplicates);\r
2422         Assert.IsTrue(view.IsEmpty);\r
2423         check();\r
2424         Assert.IsTrue(IC.eq(list, 0, 3));\r
2425         Assert.IsTrue(IC.eq(view));\r
2426         view.Add(8);\r
2427         Assert.IsFalse(view.IsEmpty);\r
2428         Assert.IsTrue(view.AllowsDuplicates);\r
2429         Assert.IsFalse(view.IsReadOnly);\r
2430         check();\r
2431         Assert.IsTrue(IC.eq(list, 0, 8, 3));\r
2432         Assert.IsTrue(IC.eq(view, 8));\r
2433         view.Add(12);\r
2434         check();\r
2435         Assert.IsTrue(IC.eq(list, 0, 8, 12, 3));\r
2436         Assert.IsTrue(IC.eq(view, 8, 12));\r
2437         view./*ViewOf(12)*/InsertLast(15);\r
2438         check();\r
2439         Assert.IsTrue(IC.eq(list, 0, 8, 12, 15, 3));\r
2440         Assert.IsTrue(IC.eq(view, 8, 12, 15));\r
2441         view.ViewOf(12).InsertFirst(18);\r
2442         check();\r
2443         Assert.IsTrue(IC.eq(list, 0, 8, 18, 12, 15, 3));\r
2444         Assert.IsTrue(IC.eq(view, 8, 18, 12, 15));\r
2445 \r
2446         ArrayList<int> lst2 = new ArrayList<int>();\r
2447 \r
2448         lst2.Add(90); lst2.Add(92);\r
2449         view.AddAll(lst2);\r
2450         check();\r
2451         Assert.IsTrue(IC.eq(list, 0, 8, 18, 12, 15, 90, 92, 3));\r
2452         Assert.IsTrue(IC.eq(view, 8, 18, 12, 15, 90, 92));\r
2453         view.InsertLast(66);\r
2454         check();\r
2455 \r
2456         Assert.IsTrue(IC.eq(list, 0, 8, 18, 12, 15, 90, 92, 66, 3));\r
2457         Assert.IsTrue(IC.eq(view, 8, 18, 12, 15, 90, 92, 66));\r
2458       }\r
2459 \r
2460 \r
2461       [Test]\r
2462       public void Bxxx()\r
2463       {\r
2464         Assert.IsTrue(IC.eq(view.Backwards(), 2, 1));\r
2465         Assert.AreSame(list, view.Underlying);\r
2466         Assert.IsNull(list.Underlying);\r
2467         Assert.AreEqual(EnumerationDirection.Forwards, view.Direction);\r
2468         Assert.AreEqual(EnumerationDirection.Backwards, view.Backwards().Direction);\r
2469         Assert.AreEqual(0, list.Offset);\r
2470         Assert.AreEqual(1, view.Offset);\r
2471       }\r
2472 \r
2473 \r
2474       [Test]\r
2475       public void Contains()\r
2476       {\r
2477         Assert.IsTrue(view.Contains(1));\r
2478         Assert.IsFalse(view.Contains(0));\r
2479 \r
2480         ArrayList<int> lst2 = new ArrayList<int>();\r
2481 \r
2482         lst2.Add(2);\r
2483         Assert.IsTrue(view.ContainsAll(lst2));\r
2484         lst2.Add(3);\r
2485         Assert.IsFalse(view.ContainsAll(lst2));\r
2486         Assert.AreEqual(Speed.Linear, view.ContainsSpeed);\r
2487         Assert.AreEqual(2, view.Count);\r
2488         view.Add(1);\r
2489         Assert.AreEqual(1, view.ContainsCount(2));\r
2490         Assert.AreEqual(2, view.ContainsCount(1));\r
2491         Assert.AreEqual(3, view.Count);\r
2492       }\r
2493 \r
2494 \r
2495       [Test]\r
2496       public void CreateView()\r
2497       {\r
2498         ArrayList<int> view2 = (ArrayList<int>)view.View(1, 0);\r
2499 \r
2500         Assert.AreSame(list, view2.Underlying);\r
2501       }\r
2502 \r
2503 \r
2504       [Test]\r
2505       public void FIFO()\r
2506       {\r
2507         Assert.IsFalse(view.FIFO);\r
2508         view.FIFO = true;\r
2509         view.Add(23); view.Add(24); view.Add(25);\r
2510         check();\r
2511         Assert.IsTrue(IC.eq(view, 1, 2, 23, 24, 25));\r
2512         Assert.AreEqual(1, view.Remove());\r
2513         check();\r
2514         Assert.IsTrue(IC.eq(view, 2, 23, 24, 25));\r
2515         view.FIFO = false;\r
2516         Assert.IsFalse(view.FIFO);\r
2517         Assert.AreEqual(25, view.Remove());\r
2518         check();\r
2519         Assert.IsTrue(IC.eq(view, 2, 23, 24));\r
2520       }\r
2521 \r
2522 \r
2523       [Test]\r
2524       public void MapEtc()\r
2525       {\r
2526         ArrayList<double> dbl = (ArrayList<double>)view.Map(new Fun<int, double>(delegate(int i) { return i / 10.0; }));\r
2527 \r
2528         Assert.IsTrue(dbl.Check());\r
2529         Assert.AreEqual(0.1, dbl[0]);\r
2530         Assert.AreEqual(0.2, dbl[1]);\r
2531         for (int i = 0; i < 10; i++) view.Add(i);\r
2532 \r
2533         list = (ArrayList<int>)view.FindAll(new Fun<int, bool>(delegate(int i) { return i % 4 == 1; }));\r
2534         Assert.IsTrue(list.Check());\r
2535         Assert.IsTrue(IC.eq(list, 1, 1, 5, 9));\r
2536       }\r
2537 \r
2538 \r
2539       [Test]\r
2540       public void FL()\r
2541       {\r
2542         Assert.AreEqual(1, view.First);\r
2543         Assert.AreEqual(2, view.Last);\r
2544       }\r
2545 \r
2546 \r
2547       [Test]\r
2548       public void Indexing()\r
2549       {\r
2550         list.Clear();\r
2551         for (int i = 0; i < 20; i++) list.Add(i);\r
2552 \r
2553         view = (ArrayList<int>)list.View(5, 7);\r
2554         for (int i = 0; i < 7; i++) Assert.AreEqual(i + 5, view[i]);\r
2555 \r
2556         for (int i = 0; i < 7; i++) Assert.AreEqual(i, view.IndexOf(i + 5));\r
2557 \r
2558         for (int i = 0; i < 7; i++) Assert.AreEqual(i, view.LastIndexOf(i + 5));\r
2559       }\r
2560 \r
2561 \r
2562       [Test]\r
2563       public void Insert()\r
2564       {\r
2565         view.Insert(0, 34);\r
2566         view.Insert(1, 35);\r
2567         view.Insert(4, 36);\r
2568         Assert.IsTrue(view.Check());\r
2569         Assert.IsTrue(IC.eq(view, 34, 35, 1, 2, 36));\r
2570 \r
2571         IList<int> list2 = new ArrayList<int>();\r
2572 \r
2573         list2.AddAll(view);\r
2574         view.InsertAll(3, list2);\r
2575         Assert.IsTrue(view.Check());\r
2576         Assert.IsTrue(IC.eq(view, 34, 35, 1, 34, 35, 1, 2, 36, 2, 36));\r
2577       }\r
2578 \r
2579       [Test]\r
2580       [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
2581       public void RangeCheck1()\r
2582       {\r
2583         IList<int> lst = new ArrayList<int>();\r
2584         lst.Add(2);\r
2585         lst = lst.View(1, 1);\r
2586       }\r
2587 \r
2588       [Test]\r
2589       [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
2590       public void RangeCheck2()\r
2591       {\r
2592         IList<int> lst = new ArrayList<int>();\r
2593         lst.Add(2);\r
2594         lst = lst.View(1, -1);\r
2595       }\r
2596 \r
2597 \r
2598       [Test]\r
2599       public void Sort()\r
2600       {\r
2601         view.Add(45); view.Add(47); view.Add(46); view.Add(48);\r
2602         Assert.IsFalse(view.IsSorted(new IC()));\r
2603         view.Sort(new IC());\r
2604         check();\r
2605         Assert.IsTrue(IC.eq(list, 0, 1, 2, 45, 46, 47, 48, 3));\r
2606         Assert.IsTrue(IC.eq(view, 1, 2, 45, 46, 47, 48));\r
2607       }\r
2608 \r
2609 \r
2610       [Test]\r
2611       public void Remove()\r
2612       {\r
2613         view.Add(1); view.Add(5); view.Add(3); view.Add(1); view.Add(3); view.Add(0);\r
2614         Assert.IsTrue(IC.eq(view, 1, 2, 1, 5, 3, 1, 3, 0));\r
2615         Assert.IsTrue(view.Remove(1));\r
2616         check();\r
2617         Assert.IsTrue(IC.eq(view, 1, 2, 1, 5, 3, 3, 0));\r
2618         Assert.IsTrue(view.Remove(1));\r
2619         check();\r
2620         Assert.IsTrue(IC.eq(view, 1, 2, 5, 3, 3, 0));\r
2621         Assert.IsTrue(view.Remove(0));\r
2622         check();\r
2623         Assert.IsTrue(IC.eq(view, 1, 2, 5, 3, 3));\r
2624         view.RemoveAllCopies(3);\r
2625         check();\r
2626         Assert.IsTrue(IC.eq(view, 1, 2, 5));\r
2627         Assert.IsTrue(IC.eq(list, 0, 1, 2, 5, 3));\r
2628         view.Add(1); view.Add(5); view.Add(3); view.Add(1); view.Add(3); view.Add(0);\r
2629         Assert.IsTrue(IC.eq(view, 1, 2, 5, 1, 5, 3, 1, 3, 0));\r
2630 \r
2631         view.FIFO = true;\r
2632         view.Clear(); view.Add(1); view.Add(2);\r
2633 \r
2634         view.Add(1); view.Add(5); view.Add(3); view.Add(1); view.Add(3); view.Add(0);\r
2635         Assert.IsTrue(IC.eq(view, 1, 2, 1, 5, 3, 1, 3, 0));\r
2636         Assert.IsTrue(view.Remove(1));\r
2637         check();\r
2638         Assert.IsTrue(IC.eq(view, 2, 1, 5, 3, 1, 3, 0));\r
2639         Assert.IsTrue(view.Remove(1));\r
2640         check();\r
2641         Assert.IsTrue(IC.eq(view, 2, 5, 3, 1, 3, 0));\r
2642         Assert.IsTrue(view.Remove(0));\r
2643         check();\r
2644         Assert.IsTrue(IC.eq(view, 2, 5, 3, 1, 3));\r
2645         view.RemoveAllCopies(3);\r
2646         check();\r
2647         Assert.IsTrue(IC.eq(view, 2, 5, 1));\r
2648         Assert.IsTrue(IC.eq(list, 0, 2, 5, 1, 3));\r
2649         view.Add(1); view.Add(5); view.Add(3); view.Add(1); view.Add(3); view.Add(0);\r
2650         Assert.IsTrue(IC.eq(view, 2, 5, 1, 1, 5, 3, 1, 3, 0));\r
2651 \r
2652         view.FIFO = false;\r
2653 \r
2654         ArrayList<int> l2 = new ArrayList<int>();\r
2655 \r
2656         l2.Add(1); l2.Add(2); l2.Add(2); l2.Add(3); l2.Add(1);\r
2657         view.RemoveAll(l2);\r
2658         check();\r
2659         Assert.IsTrue(IC.eq(view, 5, 5, 1, 3, 0));\r
2660         view.RetainAll(l2);\r
2661         check();\r
2662         Assert.IsTrue(IC.eq(view, 1, 3));\r
2663         view.Add(2); view.Add(4); view.Add(5);\r
2664         Assert.AreEqual(1, view.RemoveAt(0));\r
2665         Assert.AreEqual(5, view.RemoveAt(3));\r
2666         Assert.AreEqual(2, view.RemoveAt(1));\r
2667         check();\r
2668         Assert.IsTrue(IC.eq(view, 3, 4));\r
2669         view.Add(8);\r
2670         Assert.AreEqual(3, view.RemoveFirst());\r
2671         Assert.AreEqual(8, view.RemoveLast());\r
2672         view.Add(2); view.Add(5); view.Add(3); view.Add(1);\r
2673         view.RemoveInterval(1, 2);\r
2674         check();\r
2675         Assert.IsTrue(IC.eq(view, 4, 3, 1));\r
2676       }\r
2677 \r
2678 \r
2679       [Test]\r
2680       public void Reverse()\r
2681       {\r
2682         view.Clear();\r
2683         for (int i = 0; i < 10; i++) view.Add(10 + i);\r
2684 \r
2685         view.View(3, 4).Reverse();\r
2686         check();\r
2687         Assert.IsTrue(IC.eq(view, 10, 11, 12, 16, 15, 14, 13, 17, 18, 19));\r
2688         view.Reverse();\r
2689         Assert.IsTrue(IC.eq(view, 19, 18, 17, 13, 14, 15, 16, 12, 11, 10));\r
2690         Assert.IsTrue(IC.eq(list, 0, 19, 18, 17, 13, 14, 15, 16, 12, 11, 10, 3));\r
2691       }\r
2692 \r
2693 \r
2694       [Test]\r
2695       public void Slide()\r
2696       {\r
2697         view.Slide(1);\r
2698         check();\r
2699         Assert.IsTrue(IC.eq(view, 2, 3));\r
2700         view.Slide(-2);\r
2701         check();\r
2702         Assert.IsTrue(IC.eq(view, 0, 1));\r
2703         view.Slide(0, 3);\r
2704         check();\r
2705         Assert.IsTrue(IC.eq(view, 0, 1, 2));\r
2706         view.Slide(2, 1);\r
2707         check();\r
2708         Assert.IsTrue(IC.eq(view, 2));\r
2709         Assert.AreEqual(view, view.Slide(-1, 0));\r
2710         check();\r
2711         Assert.IsTrue(IC.eq(view));\r
2712         view.Add(28);\r
2713         Assert.IsTrue(IC.eq(list, 0, 28, 1, 2, 3));\r
2714       }\r
2715       [Test]\r
2716       public void Iterate()\r
2717       {\r
2718         list.Clear();\r
2719         view = null;\r
2720         foreach (int i in new int[] { 2, 4, 8, 13, 6, 1, 2, 7 }) list.Add(i);\r
2721 \r
2722         view = (ArrayList<int>)list.View(list.Count - 2, 2);\r
2723         while (true)\r
2724         {\r
2725           if ((view.Last - view.First) % 2 == 1)\r
2726             view.Insert(1, 666);\r
2727           check();\r
2728           if (view.Offset == 0)\r
2729             break;\r
2730           else\r
2731             view.Slide(-1, 2);\r
2732         }\r
2733         Assert.IsTrue(list.Check());\r
2734         Assert.IsTrue(IC.eq(list, 2, 4, 8, 666, 13, 6, 1, 666, 2, 666, 7));\r
2735       }\r
2736 \r
2737 \r
2738       [Test]\r
2739       public void SyncRoot()\r
2740       {\r
2741         Assert.AreSame(view.SyncRoot, list.SyncRoot);\r
2742       }\r
2743     }\r
2744     [TestFixture]\r
2745     public class MulipleViews\r
2746     {\r
2747       IList<int> list;\r
2748       IList<int>[][] views;\r
2749       [SetUp]\r
2750       public void Init()\r
2751       {\r
2752         list = new ArrayList<int>();\r
2753         for (int i = 0; i < 6; i++)\r
2754           list.Add(i);\r
2755         views = new IList<int>[7][];\r
2756         for (int i = 0; i < 7; i++)\r
2757         {\r
2758           views[i] = new IList<int>[7 - i];\r
2759           for (int j = 0; j < 7 - i; j++)\r
2760             views[i][j] = list.View(i, j);\r
2761         }\r
2762       }\r
2763       [TearDown]\r
2764       public void Dispose()\r
2765       {\r
2766         list = null;\r
2767         views = null;\r
2768       }\r
2769       [Test]\r
2770       public void Insert()\r
2771       {\r
2772         Assert.IsTrue(list.Check(), "list check before insert");\r
2773         list.Insert(3, 777);\r
2774         Assert.IsTrue(list.Check(), "list check after insert");\r
2775         for (int i = 0; i < 7; i++)\r
2776           for (int j = 0; j < 7 - i; j++)\r
2777           {\r
2778             Assert.AreEqual(i < 3 || (i == 3 && j == 0) ? i : i + 1, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
2779             Assert.AreEqual(i < 3 && i + j > 3 ? j + 1 : j, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
2780           }\r
2781       }\r
2782       [Test]\r
2783       public void RemoveAt()\r
2784       {\r
2785         Assert.IsTrue(list.Check(), "list check before remove");\r
2786         list.RemoveAt(3);\r
2787         Assert.IsTrue(list.Check(), "list check after remove");\r
2788         for (int i = 0; i < 7; i++)\r
2789           for (int j = 0; j < 7 - i; j++)\r
2790           {\r
2791             Assert.AreEqual(i <= 3 ? i : i - 1, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
2792             Assert.AreEqual(i <= 3 && i + j > 3 ? j - 1 : j, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
2793           }\r
2794       }\r
2795 \r
2796       [Test]\r
2797       public void RemoveInterval()\r
2798       {\r
2799         Assert.IsTrue(list.Check(), "list check before remove");\r
2800         list.RemoveInterval(3, 2);\r
2801         Assert.IsTrue(list.Check(), "list check after remove");\r
2802         for (int i = 0; i < 7; i++)\r
2803           for (int j = 0; j < 7 - i; j++)\r
2804           {\r
2805             Assert.AreEqual(i <= 3 ? i : i <= 5 ? 3 : i - 2, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
2806             Assert.AreEqual(j == 0 ? 0 : i <= 3 && i + j > 4 ? j - 2 : i > 4 || i + j <= 3 ? j : j - 1, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
2807           }\r
2808       }\r
2809 \r
2810 \r
2811       [Test]\r
2812       public void InsertAtEnd()\r
2813       {\r
2814         Assert.IsTrue(list.Check(), "list check before insert");\r
2815         list.InsertLast(777);\r
2816         Assert.IsTrue(list.Check(), "list check after insert");\r
2817         for (int i = 0; i < 7; i++)\r
2818           for (int j = 0; j < 7 - i; j++)\r
2819           {\r
2820             Assert.AreEqual(i, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
2821             Assert.AreEqual(j, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
2822           }\r
2823       }\r
2824       [Test]\r
2825       public void RemoveAtEnd()\r
2826       {\r
2827         Assert.IsTrue(list.Check(), "list check before remove");\r
2828         list.RemoveAt(5);\r
2829         Assert.IsTrue(list.Check(), "list check after remove");\r
2830         for (int i = 0; i < 7; i++)\r
2831           for (int j = 0; j < 7 - i; j++)\r
2832           {\r
2833             Assert.AreEqual(i <= 5 ? i : i - 1, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
2834             Assert.AreEqual(i <= 5 && i + j > 5 ? j - 1 : j, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
2835           }\r
2836       }\r
2837       [Test]\r
2838       public void InsertAtStart()\r
2839       {\r
2840         Assert.IsTrue(list.Check(), "list check before insert");\r
2841         list.Insert(0, 777);\r
2842         Assert.IsTrue(list.Check(), "list check after insert");\r
2843         for (int i = 0; i < 7; i++)\r
2844           for (int j = 0; j < 7 - i; j++)\r
2845           {\r
2846             Assert.AreEqual(i == 0 && j == 0 ? 0 : i + 1, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
2847             Assert.AreEqual(j, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
2848           }\r
2849       }\r
2850       [Test]\r
2851       public void RemoveAtStart()\r
2852       {\r
2853         Assert.IsTrue(list.Check(), "list check before remove");\r
2854         list.RemoveAt(0);\r
2855         Assert.IsTrue(list.Check(), "list check after remove");\r
2856         for (int i = 0; i < 7; i++)\r
2857           for (int j = 0; j < 7 - i; j++)\r
2858           {\r
2859             Assert.AreEqual(i == 0 ? i : i - 1, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
2860             Assert.AreEqual(i == 0 && j > 0 ? j - 1 : j, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
2861           }\r
2862       }\r
2863       [Test]\r
2864       public void Clear()\r
2865       {\r
2866         Assert.IsTrue(list.Check(), "list check before clear");\r
2867         views[2][3].Clear();\r
2868         Assert.IsTrue(list.Check(), "list check after clear");\r
2869         for (int i = 0; i < 7; i++)\r
2870           for (int j = 0; j < 7 - i; j++)\r
2871           {\r
2872             Assert.AreEqual(i < 2 ? i : i < 6 ? 2 : i - 3, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
2873             Assert.AreEqual(s(i, j), views[i][j].Count, "view[" + i + "][" + j + "] count");\r
2874           }\r
2875       }\r
2876 \r
2877       private int s(int i, int j)\r
2878       {\r
2879         if (j == 0) return 0;\r
2880         int k = i + j - 1; //end\r
2881         if (i > 4 || k <= 1) return j;\r
2882         if (i >= 2) return k > 4 ? k - 4 : 0;\r
2883         if (i <= 2) return k >= 4 ? j - 3 : 2 - i;\r
2884         return -1;\r
2885       }\r
2886       [Test]\r
2887       public void InsertAll()\r
2888       {\r
2889         ArrayList<int> list2 = new ArrayList<int>();\r
2890         for (int i = 0; i < 5; i++) { list2.Add(100 + i); }\r
2891         Assert.IsTrue(list.Check(), "list check before insertAll");\r
2892         list.InsertAll(3, list2);\r
2893         Assert.IsTrue(list.Check(), "list check after insertAll");\r
2894         for (int i = 0; i < 7; i++)\r
2895           for (int j = 0; j < 7 - i; j++)\r
2896           {\r
2897             Assert.AreEqual(i < 3 || (i == 3 && j == 0) ? i : i + 5, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
2898             Assert.AreEqual(i < 3 && i + j > 3 ? j + 5 : j, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
2899           }\r
2900       }\r
2901 \r
2902       [Test]\r
2903       public void AddAll()\r
2904       {\r
2905         ArrayList<int> list2 = new ArrayList<int>();\r
2906         for (int i = 0; i < 5; i++) { list2.Add(100 + i); }\r
2907         Assert.IsTrue(list.Check(), "list check before AddAll");\r
2908         list.View(1, 2).AddAll(list2);\r
2909         Assert.IsTrue(list.Check(), "list check after AddAll");\r
2910         for (int i = 0; i < 7; i++)\r
2911           for (int j = 0; j < 7 - i; j++)\r
2912           {\r
2913             Assert.AreEqual(i < 3 || (i == 3 && j == 0) ? i : i + 5, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
2914             Assert.AreEqual(i < 3 && i + j > 3 ? j + 5 : j, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
2915           }\r
2916       }\r
2917 \r
2918       [Test]\r
2919       public void RemoveAll1()\r
2920       {\r
2921         ArrayList<int> list2 = new ArrayList<int>();\r
2922         list2.Add(1); list2.Add(3); list2.Add(4);\r
2923 \r
2924         for (int i = 0; i < 7; i++)\r
2925         {\r
2926           for (int j = 0; j < 7 - i; j++)\r
2927           {\r
2928             list = new ArrayList<int>();\r
2929             for (int k = 0; k < 6; k++) list.Add(k);\r
2930             ArrayList<int> v = (ArrayList<int>)list.View(i, j);\r
2931             list.RemoveAll(list2);\r
2932             Assert.IsTrue(list.Check(), "list check after RemoveAll, i=" + i + ", j=" + j);\r
2933           }\r
2934         }\r
2935       }\r
2936       [Test]\r
2937       public void RemoveAll2()\r
2938       {\r
2939         ArrayList<int> list2 = new ArrayList<int>();\r
2940         list2.Add(1); list2.Add(3); list2.Add(4);\r
2941         Assert.IsTrue(list.Check(), "list check before RemoveAll");\r
2942         list.RemoveAll(list2);\r
2943 \r
2944         Assert.AreEqual(0, views[0][0].Offset, "view [0][0] offset");\r
2945         Assert.AreEqual(0, views[0][1].Offset, "view [0][1] offset");\r
2946         Assert.AreEqual(0, views[0][2].Offset, "view [0][2] offset");\r
2947         Assert.AreEqual(0, views[0][3].Offset, "view [0][3] offset");\r
2948         Assert.AreEqual(0, views[0][4].Offset, "view [0][4] offset");\r
2949         Assert.AreEqual(0, views[0][5].Offset, "view [0][5] offset");\r
2950         Assert.AreEqual(0, views[0][6].Offset, "view [0][6] offset");\r
2951         Assert.AreEqual(1, views[1][0].Offset, "view [1][0] offset");\r
2952         Assert.AreEqual(1, views[1][1].Offset, "view [1][1] offset");\r
2953         Assert.AreEqual(1, views[1][2].Offset, "view [1][2] offset");\r
2954         Assert.AreEqual(1, views[1][3].Offset, "view [1][3] offset");\r
2955         Assert.AreEqual(1, views[1][4].Offset, "view [1][4] offset");\r
2956         Assert.AreEqual(1, views[1][5].Offset, "view [1][5] offset");\r
2957         Assert.AreEqual(1, views[2][0].Offset, "view [2][0] offset");\r
2958         Assert.AreEqual(1, views[2][1].Offset, "view [2][1] offset");\r
2959         Assert.AreEqual(1, views[2][2].Offset, "view [2][2] offset");\r
2960         Assert.AreEqual(1, views[2][3].Offset, "view [2][3] offset");\r
2961         Assert.AreEqual(1, views[2][4].Offset, "view [2][4] offset");\r
2962         Assert.AreEqual(2, views[3][0].Offset, "view [3][0] offset");\r
2963         Assert.AreEqual(2, views[3][1].Offset, "view [3][1] offset");\r
2964         Assert.AreEqual(2, views[3][2].Offset, "view [3][2] offset");\r
2965         Assert.AreEqual(2, views[3][3].Offset, "view [3][3] offset");\r
2966         Assert.AreEqual(2, views[4][0].Offset, "view [4][0] offset");\r
2967         Assert.AreEqual(2, views[4][1].Offset, "view [4][1] offset");\r
2968         Assert.AreEqual(2, views[4][2].Offset, "view [4][2] offset");\r
2969         Assert.AreEqual(2, views[5][0].Offset, "view [5][0] offset");\r
2970         Assert.AreEqual(2, views[5][1].Offset, "view [5][1] offset");\r
2971         Assert.AreEqual(3, views[6][0].Offset, "view [6][0] offset");\r
2972 \r
2973         Assert.AreEqual(0, views[0][0].Count, "view [0][0] count");\r
2974         Assert.AreEqual(1, views[0][1].Count, "view [0][1] count");\r
2975         Assert.AreEqual(1, views[0][2].Count, "view [0][2] count");\r
2976         Assert.AreEqual(2, views[0][3].Count, "view [0][3] count");\r
2977         Assert.AreEqual(2, views[0][4].Count, "view [0][4] count");\r
2978         Assert.AreEqual(2, views[0][5].Count, "view [0][5] count");\r
2979         Assert.AreEqual(3, views[0][6].Count, "view [0][6] count");\r
2980         Assert.AreEqual(0, views[1][0].Count, "view [1][0] count");\r
2981         Assert.AreEqual(0, views[1][1].Count, "view [1][1] count");\r
2982         Assert.AreEqual(1, views[1][2].Count, "view [1][2] count");\r
2983         Assert.AreEqual(1, views[1][3].Count, "view [1][3] count");\r
2984         Assert.AreEqual(1, views[1][4].Count, "view [1][4] count");\r
2985         Assert.AreEqual(2, views[1][5].Count, "view [1][5] count");\r
2986         Assert.AreEqual(0, views[2][0].Count, "view [2][0] count");\r
2987         Assert.AreEqual(1, views[2][1].Count, "view [2][1] count");\r
2988         Assert.AreEqual(1, views[2][2].Count, "view [2][2] count");\r
2989         Assert.AreEqual(1, views[2][3].Count, "view [2][3] count");\r
2990         Assert.AreEqual(2, views[2][4].Count, "view [2][4] count");\r
2991         Assert.AreEqual(0, views[3][0].Count, "view [3][0] count");\r
2992         Assert.AreEqual(0, views[3][1].Count, "view [3][1] count");\r
2993         Assert.AreEqual(0, views[3][2].Count, "view [3][2] count");\r
2994         Assert.AreEqual(1, views[3][3].Count, "view [3][3] count");\r
2995         Assert.AreEqual(0, views[4][0].Count, "view [4][0] count");\r
2996         Assert.AreEqual(0, views[4][1].Count, "view [4][1] count");\r
2997         Assert.AreEqual(1, views[4][2].Count, "view [4][2] count");\r
2998         Assert.AreEqual(0, views[5][0].Count, "view [5][0] count");\r
2999         Assert.AreEqual(1, views[5][1].Count, "view [5][1] count");\r
3000         Assert.AreEqual(0, views[6][0].Count, "view [6][0] count");\r
3001 \r
3002         Assert.IsTrue(list.Check(), "list check after RemoveAll");\r
3003       }\r
3004 \r
3005       [Test]\r
3006       public void RetainAll()\r
3007       {\r
3008         ArrayList<int> list2 = new ArrayList<int>();\r
3009         list2.Add(2); list2.Add(4); list2.Add(5);\r
3010         Assert.IsTrue(list.Check(), "list check before RetainAll");\r
3011         list.RetainAll(list2);\r
3012 \r
3013         Assert.AreEqual(0, views[0][0].Offset, "view [0][0] offset");\r
3014         Assert.AreEqual(0, views[0][1].Offset, "view [0][1] offset");\r
3015         Assert.AreEqual(0, views[0][2].Offset, "view [0][2] offset");\r
3016         Assert.AreEqual(0, views[0][3].Offset, "view [0][3] offset");\r
3017         Assert.AreEqual(0, views[0][4].Offset, "view [0][4] offset");\r
3018         Assert.AreEqual(0, views[0][5].Offset, "view [0][5] offset");\r
3019         Assert.AreEqual(0, views[0][6].Offset, "view [0][6] offset");\r
3020         Assert.AreEqual(0, views[1][0].Offset, "view [1][0] offset");\r
3021         Assert.AreEqual(0, views[1][1].Offset, "view [1][1] offset");\r
3022         Assert.AreEqual(0, views[1][2].Offset, "view [1][2] offset");\r
3023         Assert.AreEqual(0, views[1][3].Offset, "view [1][3] offset");\r
3024         Assert.AreEqual(0, views[1][4].Offset, "view [1][4] offset");\r
3025         Assert.AreEqual(0, views[1][5].Offset, "view [1][5] offset");\r
3026         Assert.AreEqual(0, views[2][0].Offset, "view [2][0] offset");\r
3027         Assert.AreEqual(0, views[2][1].Offset, "view [2][1] offset");\r
3028         Assert.AreEqual(0, views[2][2].Offset, "view [2][2] offset");\r
3029         Assert.AreEqual(0, views[2][3].Offset, "view [2][3] offset");\r
3030         Assert.AreEqual(0, views[2][4].Offset, "view [2][4] offset");\r
3031         Assert.AreEqual(1, views[3][0].Offset, "view [3][0] offset");\r
3032         Assert.AreEqual(1, views[3][1].Offset, "view [3][1] offset");\r
3033         Assert.AreEqual(1, views[3][2].Offset, "view [3][2] offset");\r
3034         Assert.AreEqual(1, views[3][3].Offset, "view [3][3] offset");\r
3035         Assert.AreEqual(1, views[4][0].Offset, "view [4][0] offset");\r
3036         Assert.AreEqual(1, views[4][1].Offset, "view [4][1] offset");\r
3037         Assert.AreEqual(1, views[4][2].Offset, "view [4][2] offset");\r
3038         Assert.AreEqual(2, views[5][0].Offset, "view [5][0] offset");\r
3039         Assert.AreEqual(2, views[5][1].Offset, "view [5][1] offset");\r
3040         Assert.AreEqual(3, views[6][0].Offset, "view [6][0] offset");\r
3041 \r
3042         Assert.AreEqual(0, views[0][0].Count, "view [0][0] count");\r
3043         Assert.AreEqual(0, views[0][1].Count, "view [0][1] count");\r
3044         Assert.AreEqual(0, views[0][2].Count, "view [0][2] count");\r
3045         Assert.AreEqual(1, views[0][3].Count, "view [0][3] count");\r
3046         Assert.AreEqual(1, views[0][4].Count, "view [0][4] count");\r
3047         Assert.AreEqual(2, views[0][5].Count, "view [0][5] count");\r
3048         Assert.AreEqual(3, views[0][6].Count, "view [0][6] count");\r
3049         Assert.AreEqual(0, views[1][0].Count, "view [1][0] count");\r
3050         Assert.AreEqual(0, views[1][1].Count, "view [1][1] count");\r
3051         Assert.AreEqual(1, views[1][2].Count, "view [1][2] count");\r
3052         Assert.AreEqual(1, views[1][3].Count, "view [1][3] count");\r
3053         Assert.AreEqual(2, views[1][4].Count, "view [1][4] count");\r
3054         Assert.AreEqual(3, views[1][5].Count, "view [1][5] count");\r
3055         Assert.AreEqual(0, views[2][0].Count, "view [2][0] count");\r
3056         Assert.AreEqual(1, views[2][1].Count, "view [2][1] count");\r
3057         Assert.AreEqual(1, views[2][2].Count, "view [2][2] count");\r
3058         Assert.AreEqual(2, views[2][3].Count, "view [2][3] count");\r
3059         Assert.AreEqual(3, views[2][4].Count, "view [2][4] count");\r
3060         Assert.AreEqual(0, views[3][0].Count, "view [3][0] count");\r
3061         Assert.AreEqual(0, views[3][1].Count, "view [3][1] count");\r
3062         Assert.AreEqual(1, views[3][2].Count, "view [3][2] count");\r
3063         Assert.AreEqual(2, views[3][3].Count, "view [3][3] count");\r
3064         Assert.AreEqual(0, views[4][0].Count, "view [4][0] count");\r
3065         Assert.AreEqual(1, views[4][1].Count, "view [4][1] count");\r
3066         Assert.AreEqual(2, views[4][2].Count, "view [4][2] count");\r
3067         Assert.AreEqual(0, views[5][0].Count, "view [5][0] count");\r
3068         Assert.AreEqual(1, views[5][1].Count, "view [5][1] count");\r
3069         Assert.AreEqual(0, views[6][0].Count, "view [6][0] count");\r
3070 \r
3071         Assert.IsTrue(list.Check(), "list check after RetainAll");\r
3072       }\r
3073 \r
3074       [Test]\r
3075       public void RemoveAllCopies()\r
3076       {\r
3077         ArrayList<int> list2 = new ArrayList<int>();\r
3078         list2.Add(0); list2.Add(2); list2.Add(2); list2.Add(2); list2.Add(5); list2.Add(2); list2.Add(1);\r
3079         for (int i = 0; i < 7; i++)\r
3080         {\r
3081           for (int j = 0; j < 7 - i; j++)\r
3082           {\r
3083             list = new ArrayList<int>();\r
3084             list.AddAll(list2);\r
3085             ArrayList<int> v = (ArrayList<int>)list.View(i, j);\r
3086             list.RemoveAllCopies(2);\r
3087             Assert.AreEqual((i == 0 && j > 0 ? 1 : 0) + (i <= 4 && i + j > 4 ? 1 : 0) + (i <= 6 && i + j > 6 ? 1 : 0), v.Count, "v.Count, i=" + i + ", j=" + j);\r
3088             Assert.AreEqual(i == 0 ? 0 : i <= 4 ? 1 : i <= 6 ? 2 : 3, v.Offset, "v.Offset, i=" + i + ", j=" + j);\r
3089             Assert.IsTrue(list.Check(), "list check after RemoveAllCopies, i=" + i + ", j=" + j);\r
3090           }\r
3091         }\r
3092       }\r
3093 \r
3094       private void checkDisposed(bool reverse, int start, int count)\r
3095       {\r
3096         int k = 0;\r
3097         for (int i = 0; i < 7; i++)\r
3098           for (int j = 0; j < 7 - i; j++)\r
3099           {\r
3100             if (i + j <= start || i >= start + count || (i <= start && i + j >= start + count) || (reverse && start <= i && start + count >= i + j))\r
3101             {\r
3102               try\r
3103               {\r
3104                 k = views[i][j].Count;\r
3105               }\r
3106               catch (ViewDisposedException)\r
3107               {\r
3108                 Assert.Fail("view[" + i + "][" + j + "] threw");\r
3109               }\r
3110               Assert.AreEqual(j, views[i][j].Count, "view[" + i + "][" + j + "] size");\r
3111               if (reverse && ((j > 0 && start <= i && start + count >= i + j) || (j == 0 && start < i && start + count > i)))\r
3112                 Assert.AreEqual(start + (start + count - i - j), views[i][j].Offset, "view[" + i + "][" + j + "] offset (mirrored)");\r
3113               else\r
3114                 Assert.AreEqual(i, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
3115             }\r
3116             else\r
3117             {\r
3118               try\r
3119               {\r
3120                 k = views[i][j].Count;\r
3121                 Assert.Fail("view[" + i + "][" + j + "] no throw");\r
3122               }\r
3123               catch (ViewDisposedException) { }\r
3124             }\r
3125           }\r
3126       }\r
3127 \r
3128       [Test]\r
3129       public void Reverse()\r
3130       {\r
3131         int start = 2, count = 3;\r
3132         IList<int> list2 = list.View(start, count);\r
3133         Assert.IsTrue(list.Check(), "list check before Reverse");\r
3134         list2.Reverse();\r
3135         Assert.IsTrue(list.Check(), "list check after Reverse");\r
3136         checkDisposed(true, start, count);\r
3137       }\r
3138       [Test]\r
3139       public void Sort()\r
3140       {\r
3141         int start = 2, count = 3;\r
3142         IList<int> list2 = list.View(start, count);\r
3143         Assert.IsTrue(list.Check(), "list check before Sort");\r
3144         list2.Sort();\r
3145         Assert.IsTrue(list.Check(), "list check after Sort");\r
3146         checkDisposed(false, start, count);\r
3147       }\r
3148       [Test]\r
3149       public void Shuffle()\r
3150       {\r
3151         int start = 2, count = 3;\r
3152         IList<int> list2 = list.View(start, count);\r
3153         Assert.IsTrue(list.Check(), "list check before Shuffle");\r
3154         list2.Shuffle();\r
3155         Assert.IsTrue(list.Check(), "list check after Shuffle");\r
3156         checkDisposed(false, start, count);\r
3157       }\r
3158 \r
3159 \r
3160     }\r
3161   }\r
3162 \r
3163 \r
3164 \r
3165 \r
3166   namespace ArrayListOfTreesORLists\r
3167   {\r
3168     [TestFixture]\r
3169     public class MultiLevelUnorderedOfUnOrdered\r
3170     {\r
3171       private ICollection<int> dit, dat, dut;\r
3172 \r
3173       private ICollection<ICollection<int>> Dit, Dat, Dut;\r
3174 \r
3175 \r
3176       [SetUp]\r
3177       public void Init()\r
3178       {\r
3179         dit = new ArrayList<int>();\r
3180         dat = new TreeSet<int>(Comparer<int>.Default, EqualityComparer<int>.Default);\r
3181         dut = new ArrayList<int>();\r
3182         dit.Add(2); dit.Add(1);\r
3183         dat.Add(1); dat.Add(2);\r
3184         dut.Add(3);\r
3185         Dit = new ArrayList<ICollection<int>>();\r
3186         Dat = new ArrayList<ICollection<int>>();\r
3187         Dut = new ArrayList<ICollection<int>>();\r
3188       }\r
3189 \r
3190 \r
3191       [Test]\r
3192       public void Check()\r
3193       {\r
3194         Assert.IsTrue(dit.UnsequencedEquals(dat));\r
3195         Assert.IsFalse(dit.UnsequencedEquals(dut));\r
3196       }\r
3197 \r
3198 \r
3199       [Test]\r
3200       public void Multi()\r
3201       {\r
3202         Dit.Add(dit); Dit.Add(dut); Dit.Add(dit);\r
3203         Dat.Add(dut); Dat.Add(dit); Dat.Add(dat);\r
3204         Assert.IsTrue(Dit.UnsequencedEquals(Dat));\r
3205         Assert.IsFalse(Dit.UnsequencedEquals(Dut));\r
3206       }\r
3207 \r
3208 \r
3209       [TearDown]\r
3210       public void Dispose()\r
3211       {\r
3212         dit = dat = dut = null;\r
3213         Dit = Dat = Dut = null;\r
3214       }\r
3215     }\r
3216 \r
3217 \r
3218 \r
3219     [TestFixture]\r
3220     public class MultiLevelOrderedOfUnOrdered\r
3221     {\r
3222       private ICollection<int> dit, dat, dut;\r
3223 \r
3224       private ISequenced<ICollection<int>> Dit, Dat, Dut;\r
3225 \r
3226 \r
3227       [SetUp]\r
3228       public void Init()\r
3229       {\r
3230         dit = new ArrayList<int>();\r
3231         dat = new TreeSet<int>(Comparer<int>.Default, EqualityComparer<int>.Default);\r
3232         dut = new ArrayList<int>();\r
3233         dit.Add(2); dit.Add(1);\r
3234         dat.Add(1); dat.Add(2);\r
3235         dut.Add(3);\r
3236         Dit = new ArrayList<ICollection<int>>();\r
3237         Dat = new ArrayList<ICollection<int>>();\r
3238         Dut = new ArrayList<ICollection<int>>();\r
3239       }\r
3240 \r
3241 \r
3242       [Test]\r
3243       public void Check()\r
3244       {\r
3245         Assert.IsTrue(dit.UnsequencedEquals(dat));\r
3246         Assert.IsFalse(dit.UnsequencedEquals(dut));\r
3247       }\r
3248 \r
3249 \r
3250       [Test]\r
3251       public void Multi()\r
3252       {\r
3253         Dit.Add(dit); Dit.Add(dut); Dit.Add(dit);\r
3254         Dat.Add(dut); Dat.Add(dit); Dat.Add(dat);\r
3255         Dut.Add(dit); Dut.Add(dut); Dut.Add(dat);\r
3256         Assert.IsFalse(Dit.SequencedEquals(Dat));\r
3257         Assert.IsTrue(Dit.SequencedEquals(Dut));\r
3258       }\r
3259 \r
3260 \r
3261       [TearDown]\r
3262       public void Dispose()\r
3263       {\r
3264         dit = dat = dut = null;\r
3265         Dit = Dat = Dut = null;\r
3266       }\r
3267     }\r
3268 \r
3269 \r
3270 \r
3271     [TestFixture]\r
3272     public class MultiLevelUnOrderedOfOrdered\r
3273     {\r
3274       private ISequenced<int> dit, dat, dut, dot;\r
3275 \r
3276       private ICollection<ISequenced<int>> Dit, Dat, Dut, Dot;\r
3277 \r
3278 \r
3279       [SetUp]\r
3280       public void Init()\r
3281       {\r
3282         dit = new TreeSet<int>(Comparer<int>.Default, EqualityComparer<int>.Default);\r
3283         dat = new ArrayList<int>();\r
3284         dut = new ArrayList<int>();\r
3285         dot = new ArrayList<int>();\r
3286         dit.Add(2); dit.Add(1);\r
3287         dat.Add(2); dat.Add(1);\r
3288         dut.Add(3);\r
3289         dot.Add(1); dot.Add(2);\r
3290         Dit = new ArrayList<ISequenced<int>>();\r
3291         Dat = new ArrayList<ISequenced<int>>();\r
3292         Dut = new ArrayList<ISequenced<int>>();\r
3293         Dot = new ArrayList<ISequenced<int>>();\r
3294       }\r
3295 \r
3296 \r
3297       [Test]\r
3298       public void Check()\r
3299       {\r
3300         Assert.IsFalse(dit.SequencedEquals(dat));\r
3301         Assert.IsTrue(dit.SequencedEquals(dot));\r
3302         Assert.IsFalse(dit.SequencedEquals(dut));\r
3303       }\r
3304 \r
3305 \r
3306       [Test]\r
3307       public void Multi()\r
3308       {\r
3309         Dit.Add(dit); Dit.Add(dut); Dit.Add(dit);\r
3310         Dat.Add(dut); Dat.Add(dit); Dat.Add(dat);\r
3311         Dut.Add(dot); Dut.Add(dut); Dut.Add(dit);\r
3312         Dot.Add(dit); Dot.Add(dit); Dot.Add(dut);\r
3313         Assert.IsTrue(Dit.UnsequencedEquals(Dut));\r
3314         Assert.IsFalse(Dit.UnsequencedEquals(Dat));\r
3315         Assert.IsTrue(Dit.UnsequencedEquals(Dot));\r
3316       }\r
3317 \r
3318 \r
3319       [TearDown]\r
3320       public void Dispose()\r
3321       {\r
3322         dit = dat = dut = dot = null;\r
3323         Dit = Dat = Dut = Dot = null;\r
3324       }\r
3325     }\r
3326 \r
3327 \r
3328 \r
3329     [TestFixture]\r
3330     public class MultiLevelOrderedOfOrdered\r
3331     {\r
3332       private ISequenced<int> dit, dat, dut, dot;\r
3333 \r
3334       private ISequenced<ISequenced<int>> Dit, Dat, Dut, Dot;\r
3335 \r
3336 \r
3337       [SetUp]\r
3338       public void Init()\r
3339       {\r
3340         dit = new TreeSet<int>(Comparer<int>.Default, EqualityComparer<int>.Default);\r
3341         dat = new ArrayList<int>();\r
3342         dut = new ArrayList<int>();\r
3343         dot = new ArrayList<int>();\r
3344         dit.Add(2); dit.Add(1);\r
3345         dat.Add(2); dat.Add(1);\r
3346         dut.Add(3);\r
3347         dot.Add(1); dot.Add(2);\r
3348         Dit = new ArrayList<ISequenced<int>>();\r
3349         Dat = new ArrayList<ISequenced<int>>();\r
3350         Dut = new ArrayList<ISequenced<int>>();\r
3351         Dot = new ArrayList<ISequenced<int>>();\r
3352       }\r
3353 \r
3354 \r
3355       [Test]\r
3356       public void Check()\r
3357       {\r
3358         Assert.IsFalse(dit.SequencedEquals(dat));\r
3359         Assert.IsTrue(dit.SequencedEquals(dot));\r
3360         Assert.IsFalse(dit.SequencedEquals(dut));\r
3361       }\r
3362 \r
3363 \r
3364       [Test]\r
3365       public void Multi()\r
3366       {\r
3367         Dit.Add(dit); Dit.Add(dut); Dit.Add(dit);\r
3368         Dat.Add(dut); Dat.Add(dit); Dat.Add(dat);\r
3369         Dut.Add(dot); Dut.Add(dut); Dut.Add(dit);\r
3370         Dot.Add(dit); Dot.Add(dit); Dot.Add(dut);\r
3371         Assert.IsTrue(Dit.SequencedEquals(Dut));\r
3372         Assert.IsFalse(Dit.SequencedEquals(Dat));\r
3373         Assert.IsFalse(Dit.SequencedEquals(Dot));\r
3374       }\r
3375 \r
3376 \r
3377       [TearDown]\r
3378       public void Dispose()\r
3379       {\r
3380         dit = dat = dut = dot = null;\r
3381         Dit = Dat = Dut = Dot = null;\r
3382       }\r
3383     }\r
3384   }\r
3385 \r
3386 \r
3387 \r
3388 \r
3389   namespace HashingAndEquals\r
3390   {\r
3391     [TestFixture]\r
3392     public class ISequenced\r
3393     {\r
3394       private ISequenced<int> dit, dat, dut;\r
3395 \r
3396 \r
3397       [SetUp]\r
3398       public void Init()\r
3399       {\r
3400         dit = new ArrayList<int>();\r
3401         dat = new ArrayList<int>();\r
3402         dut = new ArrayList<int>();\r
3403       }\r
3404 \r
3405 \r
3406       [Test]\r
3407       public void EmptyEmpty()\r
3408       {\r
3409         Assert.IsTrue(dit.SequencedEquals(dat));\r
3410       }\r
3411 \r
3412 \r
3413       [Test]\r
3414       public void EmptyNonEmpty()\r
3415       {\r
3416         dit.Add(3);\r
3417         Assert.IsFalse(dit.SequencedEquals(dat));\r
3418         Assert.IsFalse(dat.SequencedEquals(dit));\r
3419       }\r
3420 \r
3421       [Test]\r
3422       public void HashVal()\r
3423       {\r
3424         Assert.AreEqual(CHC.sequencedhashcode(), dit.GetSequencedHashCode());\r
3425         dit.Add(3);\r
3426         Assert.AreEqual(CHC.sequencedhashcode(3), dit.GetSequencedHashCode());\r
3427         dit.Add(7);\r
3428         Assert.AreEqual(CHC.sequencedhashcode(3, 7), dit.GetSequencedHashCode());\r
3429         Assert.AreEqual(CHC.sequencedhashcode(), dut.GetSequencedHashCode());\r
3430         dut.Add(7);\r
3431         Assert.AreEqual(CHC.sequencedhashcode(7), dut.GetSequencedHashCode());\r
3432         dut.Add(3);\r
3433         Assert.AreEqual(CHC.sequencedhashcode(7, 3), dut.GetSequencedHashCode());\r
3434       }\r
3435 \r
3436 \r
3437       [Test]\r
3438       public void EqualHashButDifferent()\r
3439       {\r
3440         dit.Add(0); dit.Add(31);\r
3441         dat.Add(1); dat.Add(0);\r
3442         Assert.AreEqual(dit.GetSequencedHashCode(), dat.GetSequencedHashCode());\r
3443         Assert.IsFalse(dit.SequencedEquals(dat));\r
3444       }\r
3445 \r
3446 \r
3447       [Test]\r
3448       public void Normal()\r
3449       {\r
3450         dit.Add(3);\r
3451         dit.Add(7);\r
3452         dat.Add(3);\r
3453         Assert.IsFalse(dit.SequencedEquals(dat));\r
3454         Assert.IsFalse(dat.SequencedEquals(dit));\r
3455         dat.Add(7);\r
3456         Assert.IsTrue(dit.SequencedEquals(dat));\r
3457         Assert.IsTrue(dat.SequencedEquals(dit));\r
3458       }\r
3459 \r
3460 \r
3461       [Test]\r
3462       public void WrongOrder()\r
3463       {\r
3464         dit.Add(3);\r
3465         dut.Add(3);\r
3466         Assert.IsTrue(dit.SequencedEquals(dut));\r
3467         Assert.IsTrue(dut.SequencedEquals(dit));\r
3468         dit.Add(7);\r
3469         ((ArrayList<int>)dut).InsertFirst(7);\r
3470         Assert.IsFalse(dit.SequencedEquals(dut));\r
3471         Assert.IsFalse(dut.SequencedEquals(dit));\r
3472       }\r
3473 \r
3474 \r
3475       [Test]\r
3476       public void Reflexive()\r
3477       {\r
3478         Assert.IsTrue(dit.SequencedEquals(dit));\r
3479         dit.Add(3);\r
3480         Assert.IsTrue(dit.SequencedEquals(dit));\r
3481         dit.Add(7);\r
3482         Assert.IsTrue(dit.SequencedEquals(dit));\r
3483       }\r
3484 \r
3485 \r
3486       [TearDown]\r
3487       public void Dispose()\r
3488       {\r
3489         dit = null;\r
3490         dat = null;\r
3491         dut = null;\r
3492       }\r
3493     }\r
3494 \r
3495 \r
3496 \r
3497     [TestFixture]\r
3498     public class IEditableCollection\r
3499     {\r
3500       private ICollection<int> dit, dat, dut;\r
3501 \r
3502 \r
3503       [SetUp]\r
3504       public void Init()\r
3505       {\r
3506         dit = new ArrayList<int>();\r
3507         dat = new ArrayList<int>();\r
3508         dut = new ArrayList<int>();\r
3509       }\r
3510 \r
3511 \r
3512       [Test]\r
3513       public void EmptyEmpty()\r
3514       {\r
3515         Assert.IsTrue(dit.UnsequencedEquals(dat));\r
3516       }\r
3517 \r
3518 \r
3519       [Test]\r
3520       public void EmptyNonEmpty()\r
3521       {\r
3522         dit.Add(3);\r
3523         Assert.IsFalse(dit.UnsequencedEquals(dat));\r
3524         Assert.IsFalse(dat.UnsequencedEquals(dit));\r
3525       }\r
3526 \r
3527 \r
3528       [Test]\r
3529       public void HashVal()\r
3530       {\r
3531         Assert.AreEqual(CHC.unsequencedhashcode(), dit.GetUnsequencedHashCode());\r
3532         dit.Add(3);\r
3533         Assert.AreEqual(CHC.unsequencedhashcode(3), dit.GetUnsequencedHashCode());\r
3534         dit.Add(7);\r
3535         Assert.AreEqual(CHC.unsequencedhashcode(3, 7), dit.GetUnsequencedHashCode());\r
3536         Assert.AreEqual(CHC.unsequencedhashcode(), dut.GetUnsequencedHashCode());\r
3537         dut.Add(3);\r
3538         Assert.AreEqual(CHC.unsequencedhashcode(3), dut.GetUnsequencedHashCode());\r
3539         dut.Add(7);\r
3540         Assert.AreEqual(CHC.unsequencedhashcode(7, 3), dut.GetUnsequencedHashCode());\r
3541       }\r
3542 \r
3543 \r
3544       [Test]\r
3545       public void EqualHashButDifferent()\r
3546       {\r
3547         dit.Add(-1657792980); dit.Add(-1570288808);\r
3548         dat.Add(1862883298); dat.Add(-272461342);\r
3549         Assert.AreEqual(dit.GetUnsequencedHashCode(), dat.GetUnsequencedHashCode());\r
3550         Assert.IsFalse(dit.UnsequencedEquals(dat));\r
3551       }\r
3552 \r
3553 \r
3554       [Test]\r
3555       public void Normal()\r
3556       {\r
3557         dit.Add(3);\r
3558         dit.Add(7);\r
3559         dat.Add(3);\r
3560         Assert.IsFalse(dit.UnsequencedEquals(dat));\r
3561         Assert.IsFalse(dat.UnsequencedEquals(dit));\r
3562         dat.Add(7);\r
3563         Assert.IsTrue(dit.UnsequencedEquals(dat));\r
3564         Assert.IsTrue(dat.UnsequencedEquals(dit));\r
3565       }\r
3566 \r
3567 \r
3568       [Test]\r
3569       public void WrongOrder()\r
3570       {\r
3571         dit.Add(3);\r
3572         dut.Add(3);\r
3573         Assert.IsTrue(dit.UnsequencedEquals(dut));\r
3574         Assert.IsTrue(dut.UnsequencedEquals(dit));\r
3575         dit.Add(7);\r
3576         dut.Add(7);\r
3577         Assert.IsTrue(dit.UnsequencedEquals(dut));\r
3578         Assert.IsTrue(dut.UnsequencedEquals(dit));\r
3579       }\r
3580 \r
3581 \r
3582       [Test]\r
3583       public void Reflexive()\r
3584       {\r
3585         Assert.IsTrue(dit.UnsequencedEquals(dit));\r
3586         dit.Add(3);\r
3587         Assert.IsTrue(dit.UnsequencedEquals(dit));\r
3588         dit.Add(7);\r
3589         Assert.IsTrue(dit.UnsequencedEquals(dit));\r
3590       }\r
3591 \r
3592 \r
3593       [TearDown]\r
3594       public void Dispose()\r
3595       {\r
3596         dit = null;\r
3597         dat = null;\r
3598         dut = null;\r
3599       }\r
3600     }\r
3601 \r
3602 \r
3603 \r
3604     [TestFixture]\r
3605     public class MultiLevelUnorderedOfUnOrdered\r
3606     {\r
3607       private ICollection<int> dit, dat, dut;\r
3608 \r
3609       private ICollection<ICollection<int>> Dit, Dat, Dut;\r
3610 \r
3611 \r
3612       [SetUp]\r
3613       public void Init()\r
3614       {\r
3615         dit = new ArrayList<int>();\r
3616         dat = new ArrayList<int>();\r
3617         dut = new ArrayList<int>();\r
3618         dit.Add(2); dit.Add(1);\r
3619         dat.Add(1); dat.Add(2);\r
3620         dut.Add(3);\r
3621         Dit = new ArrayList<ICollection<int>>();\r
3622         Dat = new ArrayList<ICollection<int>>();\r
3623         Dut = new ArrayList<ICollection<int>>();\r
3624       }\r
3625 \r
3626 \r
3627       [Test]\r
3628       public void Check()\r
3629       {\r
3630         Assert.IsTrue(dit.UnsequencedEquals(dat));\r
3631         Assert.IsFalse(dit.UnsequencedEquals(dut));\r
3632       }\r
3633 \r
3634 \r
3635       [Test]\r
3636       public void Multi()\r
3637       {\r
3638         Dit.Add(dit); Dit.Add(dut); Dit.Add(dit);\r
3639         Dat.Add(dut); Dat.Add(dit); Dat.Add(dat);\r
3640         Assert.IsTrue(Dit.UnsequencedEquals(Dat));\r
3641         Assert.IsFalse(Dit.UnsequencedEquals(Dut));\r
3642       }\r
3643 \r
3644 \r
3645       [TearDown]\r
3646       public void Dispose()\r
3647       {\r
3648         dit = dat = dut = null;\r
3649         Dit = Dat = Dut = null;\r
3650       }\r
3651     }\r
3652 \r
3653 \r
3654 \r
3655     [TestFixture]\r
3656     public class MultiLevelOrderedOfUnOrdered\r
3657     {\r
3658       private ICollection<int> dit, dat, dut;\r
3659 \r
3660       private ISequenced<ICollection<int>> Dit, Dat, Dut;\r
3661 \r
3662 \r
3663       [SetUp]\r
3664       public void Init()\r
3665       {\r
3666         dit = new ArrayList<int>();\r
3667         dat = new ArrayList<int>();\r
3668         dut = new ArrayList<int>();\r
3669         dit.Add(2); dit.Add(1);\r
3670         dat.Add(1); dat.Add(2);\r
3671         dut.Add(3);\r
3672         Dit = new ArrayList<ICollection<int>>();\r
3673         Dat = new ArrayList<ICollection<int>>();\r
3674         Dut = new ArrayList<ICollection<int>>();\r
3675       }\r
3676 \r
3677 \r
3678       [Test]\r
3679       public void Check()\r
3680       {\r
3681         Assert.IsTrue(dit.UnsequencedEquals(dat));\r
3682         Assert.IsFalse(dit.UnsequencedEquals(dut));\r
3683       }\r
3684 \r
3685 \r
3686       [Test]\r
3687       public void Multi()\r
3688       {\r
3689         Dit.Add(dit); Dit.Add(dut); Dit.Add(dit);\r
3690         Dat.Add(dut); Dat.Add(dit); Dat.Add(dat);\r
3691         Dut.Add(dit); Dut.Add(dut); Dut.Add(dat);\r
3692         Assert.IsFalse(Dit.SequencedEquals(Dat));\r
3693         Assert.IsTrue(Dit.SequencedEquals(Dut));\r
3694       }\r
3695 \r
3696 \r
3697       [TearDown]\r
3698       public void Dispose()\r
3699       {\r
3700         dit = dat = dut = null;\r
3701         Dit = Dat = Dut = null;\r
3702       }\r
3703     }\r
3704 \r
3705 \r
3706 \r
3707     [TestFixture]\r
3708     public class MultiLevelUnOrderedOfOrdered\r
3709     {\r
3710       private ISequenced<int> dit, dat, dut, dot;\r
3711 \r
3712       private ICollection<ISequenced<int>> Dit, Dat, Dut, Dot;\r
3713 \r
3714 \r
3715       [SetUp]\r
3716       public void Init()\r
3717       {\r
3718         dit = new ArrayList<int>();\r
3719         dat = new ArrayList<int>();\r
3720         dut = new ArrayList<int>();\r
3721         dot = new ArrayList<int>();\r
3722         dit.Add(2); dit.Add(1);\r
3723         dat.Add(1); dat.Add(2);\r
3724         dut.Add(3);\r
3725         dot.Add(2); dot.Add(1);\r
3726         Dit = new ArrayList<ISequenced<int>>();\r
3727         Dat = new ArrayList<ISequenced<int>>();\r
3728         Dut = new ArrayList<ISequenced<int>>();\r
3729         Dot = new ArrayList<ISequenced<int>>();\r
3730       }\r
3731 \r
3732 \r
3733       [Test]\r
3734       public void Check()\r
3735       {\r
3736         Assert.IsFalse(dit.SequencedEquals(dat));\r
3737         Assert.IsTrue(dit.SequencedEquals(dot));\r
3738         Assert.IsFalse(dit.SequencedEquals(dut));\r
3739       }\r
3740 \r
3741 \r
3742       [Test]\r
3743       public void Multi()\r
3744       {\r
3745         Dit.Add(dit); Dit.Add(dut); Dit.Add(dit);\r
3746         Dat.Add(dut); Dat.Add(dit); Dat.Add(dat);\r
3747         Dut.Add(dot); Dut.Add(dut); Dut.Add(dit);\r
3748         Dot.Add(dit); Dot.Add(dit); Dot.Add(dut);\r
3749         Assert.IsTrue(Dit.UnsequencedEquals(Dut));\r
3750         Assert.IsFalse(Dit.UnsequencedEquals(Dat));\r
3751         Assert.IsTrue(Dit.UnsequencedEquals(Dot));\r
3752       }\r
3753 \r
3754 \r
3755       [TearDown]\r
3756       public void Dispose()\r
3757       {\r
3758         dit = dat = dut = dot = null;\r
3759         Dit = Dat = Dut = Dot = null;\r
3760       }\r
3761     }\r
3762 \r
3763 \r
3764 \r
3765     [TestFixture]\r
3766     public class MultiLevelOrderedOfOrdered\r
3767     {\r
3768       private ISequenced<int> dit, dat, dut, dot;\r
3769 \r
3770       private ISequenced<ISequenced<int>> Dit, Dat, Dut, Dot;\r
3771 \r
3772 \r
3773       [SetUp]\r
3774       public void Init()\r
3775       {\r
3776         dit = new ArrayList<int>();\r
3777         dat = new ArrayList<int>();\r
3778         dut = new ArrayList<int>();\r
3779         dot = new ArrayList<int>();\r
3780         dit.Add(2); dit.Add(1);\r
3781         dat.Add(1); dat.Add(2);\r
3782         dut.Add(3);\r
3783         dot.Add(2); dot.Add(1);\r
3784         Dit = new ArrayList<ISequenced<int>>();\r
3785         Dat = new ArrayList<ISequenced<int>>();\r
3786         Dut = new ArrayList<ISequenced<int>>();\r
3787         Dot = new ArrayList<ISequenced<int>>();\r
3788       }\r
3789 \r
3790 \r
3791       [Test]\r
3792       public void Check()\r
3793       {\r
3794         Assert.IsFalse(dit.SequencedEquals(dat));\r
3795         Assert.IsTrue(dit.SequencedEquals(dot));\r
3796         Assert.IsFalse(dit.SequencedEquals(dut));\r
3797       }\r
3798 \r
3799 \r
3800       [Test]\r
3801       public void Multi()\r
3802       {\r
3803         Dit.Add(dit); Dit.Add(dut); Dit.Add(dit);\r
3804         Dat.Add(dut); Dat.Add(dit); Dat.Add(dat);\r
3805         Dut.Add(dot); Dut.Add(dut); Dut.Add(dit);\r
3806         Dot.Add(dit); Dot.Add(dit); Dot.Add(dut);\r
3807         Assert.IsTrue(Dit.SequencedEquals(Dut));\r
3808         Assert.IsFalse(Dit.SequencedEquals(Dat));\r
3809         Assert.IsFalse(Dit.SequencedEquals(Dot));\r
3810       }\r
3811 \r
3812 \r
3813       [TearDown]\r
3814       public void Dispose()\r
3815       {\r
3816         dit = dat = dut = dot = null;\r
3817         Dit = Dat = Dut = Dot = null;\r
3818       }\r
3819     }\r
3820   }\r
3821 }