class/Mono.C5/Test/templates/Events.cs

   1 /*
   2  Copyright (c) 2003-2006 Niels Kokholm and Peter Sestoft
   3  Permission is hereby granted, free of charge, to any person obtaining a copy
   4  of this software and associated documentation files (the "Software"), to deal
   5  in the Software without restriction, including without limitation the rights
   6  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   7  copies of the Software, and to permit persons to whom the Software is
   8  furnished to do so, subject to the following conditions:
   9
  10  The above copyright notice and this permission notice shall be included in
  11  all copies or substantial portions of the Software.
  12
  13  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  18  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  19  SOFTWARE.
  20 */
  21
  22 using System;
  23 using C5;
  24 using NUnit.Framework;
  25 using SCG = System.Collections.Generic;
  26 using System.Reflection;
  27
  28 namespace C5UnitTests.Templates.Events
  29 {
  30   public abstract class CollectionValueTester<TCollection, TItem> : GenericCollectionTester<TCollection, EventTypeEnum>
  31     where TCollection : ICollectionValue<TItem>
  32   {
  33     protected TCollection collection;
  34     protected CollectionEventList<TItem> seen;
  35     protected EventTypeEnum listenTo;
  36     protected void listen() { seen.Listen(collection, listenTo); }
  37
  38     public override void SetUp(TCollection list, EventTypeEnum testSpec)
  39     {
  40       this.collection = list;
  41       listenTo = testSpec;
  42       seen = new CollectionEventList<TItem>(EqualityComparer<TItem>.Default);
  43     }
  44
  45     public SCG.IEnumerable<EventTypeEnum> SpecsNone
  46     {
  47       get
  48       {
  49         CircularQueue<EventTypeEnum> specs = new CircularQueue<EventTypeEnum>();
  50         return specs;
  51       }
  52     }
  53     public SCG.IEnumerable<EventTypeEnum> SpecsBasic
  54     {
  55       get
  56       {
  57         CircularQueue<EventTypeEnum> specs = new CircularQueue<EventTypeEnum>();
  58         //foreach (EventTypeEnum listenTo in Enum.GetValues(typeof(EventTypeEnum)))
  59         //  if ((listenTo & ~EventTypeEnum.Basic) == 0)
  60         //    specs.Enqueue(listenTo);
  61         //specs.Enqueue(EventTypeEnum.Added | EventTypeEnum.Removed);
  62         for (int spec = 0; spec <= (int)EventTypeEnum.Basic; spec++)
  63           specs.Enqueue((EventTypeEnum)spec);
  64         return specs;
  65       }
  66     }
  67     public SCG.IEnumerable<EventTypeEnum> SpecsAll
  68     {
  69       get
  70       {
  71         CircularQueue<EventTypeEnum> specs = new CircularQueue<EventTypeEnum>();
  72         //foreach (EventTypeEnum listenTo in Enum.GetValues(typeof(EventTypeEnum)))
  73         //  specs.Enqueue(listenTo);
  74         //specs.Enqueue(EventTypeEnum.Added | EventTypeEnum.Removed);
  75
  76         for (int spec = 0; spec <= (int)EventTypeEnum.All; spec++)
  77           specs.Enqueue((EventTypeEnum)spec);
  78         return specs;
  79       }
  80     }
  81   }
  82   public abstract class CollectionValueTester<U> : CollectionValueTester<U, int> where U : ICollectionValue<int>
  83   {
  84   }
  85
  86   public class ExtensibleTester<U> : CollectionValueTester<U> where U : IExtensible<int>
  87   {
  88     public override SCG.IEnumerable<EventTypeEnum> GetSpecs()
  89     {
  90       return SpecsBasic;
  91     }
  92     [Test]
  93     public virtual void Listenable()
  94     {
  95       Assert.AreEqual(EventTypeEnum.Basic, collection.ListenableEvents);
  96       Assert.AreEqual(EventTypeEnum.None, collection.ActiveEvents);
  97       listen();
  98       Assert.AreEqual(listenTo, collection.ActiveEvents);
  99     }
 100
 101     [Test]
 102     public void Add()
 103     {
 104       listen();
 105       seen.Check(new CollectionEvent<int>[0]);
 106       collection.Add(23);
 107       seen.Check(new CollectionEvent<int>[] {
 108           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(23, 1), collection),
 109           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 110     }
 111
 112     [Test]
 113     public void AddAll()
 114     {
 115       for (int i = 0; i < 10; i++)
 116       {
 117         collection.Add(10 * i + 5);
 118       }
 119       listen();
 120       collection.AddAll<int>(new int[] { 45, 200, 56, 67 });
 121       seen.Check(collection.AllowsDuplicates ?
 122         collection.DuplicatesByCounting ?
 123           new CollectionEvent<int>[] {
 124           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(45, 1), collection),
 125           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(200, 1), collection),
 126           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(55, 1), collection),
 127           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(65, 1), collection),
 128           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)}
 129         :
 130           new CollectionEvent<int>[] {
 131           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(45, 1), collection),
 132           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(200, 1), collection),
 133           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(56, 1), collection),
 134           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(67, 1), collection),
 135           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)}
 136           :
 137           new CollectionEvent<int>[] {
 138           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(200, 1), collection),
 139           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 140       collection.AddAll<int>(new int[] { });
 141       seen.Check(new CollectionEvent<int>[] { });
 142     }
 143
 144   }
 145
 146   public class CollectionTester<U> : ExtensibleTester<U> where U : ICollection<int>
 147   {
 148     [Test]
 149     public void Update()
 150     {
 151       collection.Add(4); collection.Add(54); collection.Add(56); collection.Add(8);
 152       listen();
 153       collection.Update(53);
 154       seen.Check(
 155         collection.AllowsDuplicates ?
 156         collection.DuplicatesByCounting ?
 157         new CollectionEvent<int>[] {
 158           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(54, 2), collection),
 159           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(53, 2), collection),
 160           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 161           }
 162         : new CollectionEvent<int>[] {
 163           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(54, 1), collection),
 164           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(53, 1), collection),
 165           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 166           }
 167         : new CollectionEvent<int>[] {
 168           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(54, 1), collection),
 169           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(53, 1), collection),
 170           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 171           });
 172       collection.Update(67);
 173       seen.Check(new CollectionEvent<int>[] { });
 174     }
 175
 176     [Test]
 177     public void FindOrAdd()
 178     {
 179       collection.Add(4); collection.Add(56); collection.Add(8);
 180       listen();
 181       int val = 53;
 182       collection.FindOrAdd(ref val);
 183       seen.Check(new CollectionEvent<int>[] { });
 184       val = 67;
 185       collection.FindOrAdd(ref val);
 186       seen.Check(new CollectionEvent<int>[] {
 187           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(67, 1), collection),
 188           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 189         });
 190     }
 191
 192     [Test]
 193     public void UpdateOrAdd()
 194     {
 195       collection.Add(4); collection.Add(56); collection.Add(8);
 196       listen();
 197       int val = 53;
 198       collection.UpdateOrAdd(val);
 199       seen.Check(new CollectionEvent<int>[] {
 200           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(56, 1), collection),
 201           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(53, 1), collection),
 202           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 203         });
 204       val = 67;
 205       collection.UpdateOrAdd(val);
 206       seen.Check(new CollectionEvent<int>[] {
 207           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(67, 1), collection),
 208           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 209         });
 210       collection.UpdateOrAdd(51, out val);
 211       seen.Check(new CollectionEvent<int>[] {
 212           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(53, 1), collection),
 213           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(51, 1), collection),
 214           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 215         });
 216       val = 67;
 217       collection.UpdateOrAdd(81, out val);
 218       seen.Check(new CollectionEvent<int>[] {
 219           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(81, 1), collection),
 220           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 221         });
 222     }
 223
 224     [Test]
 225     public void RemoveItem()
 226     {
 227       collection.Add(4); collection.Add(56); collection.Add(18);
 228       listen();
 229       collection.Remove(53);
 230       seen.Check(new CollectionEvent<int>[] {
 231           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(56, 1), collection),
 232           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 233       collection.Remove(11);
 234       seen.Check(new CollectionEvent<int>[] {
 235           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(18, 1), collection),
 236           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 237     }
 238
 239     [Test]
 240     public void RemoveAll()
 241     {
 242       for (int i = 0; i < 10; i++)
 243       {
 244         collection.Add(10 * i + 5);
 245       }
 246       listen();
 247       collection.RemoveAll<int>(new int[] { 32, 187, 45 });
 248       //TODO: the order depends on internals of the HashSet
 249       seen.Check(new CollectionEvent<int>[] {
 250           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(35, 1), collection),
 251           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(45, 1), collection),
 252           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 253       collection.RemoveAll<int>(new int[] { 200, 300 });
 254       seen.Check(new CollectionEvent<int>[] { });
 255     }
 256
 257     [Test]
 258     [Ignore("Temporarily disabled.  2006-03-07.  Martin")]
 259     public void RetainAll()
 260     {
 261       for (int i = 0; i < 10; i++)
 262       {
 263         collection.Add(10 * i + 5);
 264       }
 265       listen();
 266       collection.RetainAll<int>(new int[] { 32, 187, 45, 62, 75, 82, 95, 2 });
 267       seen.Check(new CollectionEvent<int>[] {
 268           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(15, 1), collection),
 269           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(25, 1), collection),
 270           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(55, 1), collection),
 271           //new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(75, 1), collection),
 272           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 273       collection.RetainAll<int>(new int[] { 32, 187, 45, 62, 75, 82, 95, 2 });
 274       seen.Check(new CollectionEvent<int>[] { });
 275     }
 276
 277     [Test]
 278     public void RemoveAllCopies()
 279     {
 280       for (int i = 0; i < 10; i++)
 281       {
 282         collection.Add(3 * i + 5);
 283       }
 284       listen();
 285       collection.RemoveAllCopies(14);
 286       seen.Check(
 287         collection.AllowsDuplicates ?
 288           collection.DuplicatesByCounting ?
 289             new CollectionEvent<int>[] {
 290               new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(11, 3), collection),
 291               new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)}
 292           :
 293           new CollectionEvent<int>[] {
 294             new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(11, 1), collection),
 295             new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(14, 1), collection),
 296             new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(17, 1), collection),
 297             new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)}
 298         :
 299         new CollectionEvent<int>[] {
 300           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(11, 1), collection),
 301           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 302       collection.RemoveAllCopies(14);
 303       seen.Check(new CollectionEvent<int>[] { });
 304     }
 305
 306     [Test]
 307     public virtual void Clear()
 308     {
 309       collection.Add(4); collection.Add(56); collection.Add(8);
 310       listen();
 311       collection.Clear();
 312       seen.Check(new CollectionEvent<int>[] {
 313           new CollectionEvent<int>(EventTypeEnum.Cleared, new ClearedEventArgs(true, collection.AllowsDuplicates ? 3 : 2), collection),
 314           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 315         });
 316       collection.Clear();
 317       seen.Check(new CollectionEvent<int>[] { });
 318     }
 319
 320   }
 321
 322   public class IndexedTester<U> : CollectionTester<U> where U : IIndexed<int>
 323   {
 324     [Test]
 325     public void RemoveAt()
 326     {
 327       collection.Add(4); collection.Add(16); collection.Add(28);
 328       listen();
 329       collection.RemoveAt(1);
 330       seen.Check(new CollectionEvent<int>[] {
 331           new CollectionEvent<int>(EventTypeEnum.RemovedAt, new ItemAtEventArgs<int>(16,1), collection),
 332           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(16, 1), collection),
 333           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 334     }
 335
 336     [Test]
 337     public void RemoveInterval()
 338     {
 339       collection.Add(4); collection.Add(56); collection.Add(18);
 340       listen();
 341       collection.RemoveInterval(1, 2);
 342       seen.Check(new CollectionEvent<int>[] {
 343         collection is IList<int> ?
 344            new CollectionEvent<int>(EventTypeEnum.Cleared, new ClearedRangeEventArgs(false,2,1), collection):
 345            new CollectionEvent<int>(EventTypeEnum.Cleared, new ClearedEventArgs(false,2), collection),
 346          new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 347         });
 348       collection.RemoveInterval(1, 0);
 349       seen.Check(new CollectionEvent<int>[] { });
 350     }
 351   }
 352
 353   public class SortedIndexedTester<U> : IndexedTester<U> where U : IIndexedSorted<int>
 354   {
 355     public override SCG.IEnumerable<EventTypeEnum> GetSpecs()
 356     {
 357       return SpecsNone;
 358     }
 359     [Test]
 360     public void DeleteMinMax()
 361     {
 362       collection.Add(34);
 363       collection.Add(56);
 364       collection.Add(34);
 365       collection.Add(12);
 366       listen();
 367       collection.DeleteMax();
 368       seen.Check(new CollectionEvent<int>[] {
 369         new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(56, 1), collection),
 370         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection),
 371       });
 372       collection.DeleteMin();
 373       seen.Check(new CollectionEvent<int>[] {
 374         new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(12, 1), collection),
 375         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection),
 376       });
 377     }
 378
 379     [Test]
 380     public void AddSorted()
 381     {
 382       listen();
 383       collection.AddSorted(collection.AllowsDuplicates ? new int[] { 31, 62, 63, 93 } : new int[] { 31, 62, 93 });
 384       seen.Check(collection.AllowsDuplicates ?
 385         collection.DuplicatesByCounting ?
 386           new CollectionEvent<int>[] {
 387           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(31, 1), collection),
 388           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(62, 1), collection),
 389           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(62, 1), collection),
 390           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(93, 1), collection),
 391           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)}
 392         :
 393           new CollectionEvent<int>[] {
 394           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(31, 1), collection),
 395           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(62, 1), collection),
 396           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(63, 1), collection),
 397           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(93, 1), collection),
 398           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)}
 399           :
 400           new CollectionEvent<int>[] {
 401           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(31, 1), collection),
 402           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(62, 1), collection),
 403           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(93, 1), collection),
 404           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 405       collection.AddSorted(new int[] { });
 406       seen.Check(new CollectionEvent<int>[] { });
 407     }
 408
 409     [Test]
 410     public void RemoveRange()
 411     {
 412       for (int i = 0; i < 20; i++)
 413         collection.Add(i * 10 + 5);
 414       listen();
 415       collection.RemoveRangeFrom(173);
 416       //TODO: fix order to remove in:
 417       seen.Check(
 418           new CollectionEvent<int>[] {
 419           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(195, 1), collection),
 420           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(185, 1), collection),
 421           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(175, 1), collection),
 422           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 423       collection.RemoveRangeFromTo(83, 113);
 424       seen.Check(
 425           new CollectionEvent<int>[] {
 426           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(105, 1), collection),
 427           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(95, 1), collection),
 428           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(85, 1), collection),
 429           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 430       collection.RemoveRangeTo(33);
 431       seen.Check(
 432           new CollectionEvent<int>[] {
 433           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(5, 1), collection),
 434           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(15, 1), collection),
 435           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(25, 1), collection),
 436           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 437       collection.RemoveRangeFrom(173);
 438       seen.Check(new CollectionEvent<int>[] { });
 439       collection.RemoveRangeFromTo(83, 113);
 440       seen.Check(new CollectionEvent<int>[] { });
 441       collection.RemoveRangeTo(33);
 442       seen.Check(new CollectionEvent<int>[] { });
 443     }
 444   }
 445
 446   public class ListTester<U> : IndexedTester<U> where U : IList<int>
 447   {
 448     public override SCG.IEnumerable<EventTypeEnum> GetSpecs()
 449     {
 450       return SpecsAll;
 451     }
 452
 453     [Test]
 454     public override void Listenable()
 455     {
 456       Assert.AreEqual(EventTypeEnum.All, collection.ListenableEvents);
 457       Assert.AreEqual(EventTypeEnum.None, collection.ActiveEvents);
 458       listen();
 459       Assert.AreEqual(listenTo, collection.ActiveEvents);
 460     }
 461     [Test]
 462     public void SetThis()
 463     {
 464       collection.Add(4); collection.Add(56); collection.Add(8);
 465       listen();
 466       collection[1] = 45;
 467       seen.Check(new CollectionEvent<int>[] {
 468           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(56, 1), collection),
 469           new CollectionEvent<int>(EventTypeEnum.RemovedAt, new ItemAtEventArgs<int>(56,1), collection),
 470           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(45, 1), collection),
 471           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(45,1), collection),
 472           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 473           });
 474     }
 475
 476     [Test]
 477     public void Insert()
 478     {
 479       collection.Add(4); collection.Add(56); collection.Add(8);
 480       listen();
 481       collection.Insert(1, 45);
 482       seen.Check(new CollectionEvent<int>[] {
 483           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(45,1), collection),
 484           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(45, 1), collection),
 485           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 486           });
 487     }
 488
 489     [Test]
 490     public void InsertAll()
 491     {
 492       collection.Add(4); collection.Add(56); collection.Add(8);
 493       listen();
 494       collection.InsertAll<int>(1, new int[] { 666, 777, 888 });
 495       //seen.Print(Console.Error);
 496       seen.Check(new CollectionEvent<int>[] {
 497           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(666,1), collection),
 498           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(666, 1), collection),
 499           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(777,2), collection),
 500           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(777, 1), collection),
 501           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(888,3), collection),
 502           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(888, 1), collection),
 503           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 504           });
 505       collection.InsertAll<int>(1, new int[] { });
 506       seen.Check(new CollectionEvent<int>[] { });
 507     }
 508
 509     [Test]
 510     public void InsertFirstLast()
 511     {
 512       collection.Add(4); collection.Add(56); collection.Add(18);
 513       listen();
 514       collection.InsertFirst(45);
 515       seen.Check(new CollectionEvent<int>[] {
 516           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(45,0), collection),
 517           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(45, 1), collection),
 518           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 519           });
 520       collection.InsertLast(88);
 521       seen.Check(new CollectionEvent<int>[] {
 522           new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(88,4), collection),
 523           new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(88, 1), collection),
 524           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 525           });
 526     }
 527
 528     [Test]
 529     public void Remove()
 530     {
 531       collection.FIFO = false;
 532       collection.Add(4); collection.Add(56); collection.Add(18);
 533       listen();
 534       collection.Remove();
 535       seen.Check(new CollectionEvent<int>[] {
 536           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(18, 1), collection),
 537           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 538       collection.FIFO = true;
 539       collection.Remove();
 540       seen.Check(new CollectionEvent<int>[] {
 541           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(4, 1), collection),
 542           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 543     }
 544
 545     [Test]
 546     public void RemoveFirst()
 547     {
 548       collection.Add(4); collection.Add(56); collection.Add(18);
 549       listen();
 550       collection.RemoveFirst();
 551       seen.Check(new CollectionEvent<int>[] {
 552           new CollectionEvent<int>(EventTypeEnum.RemovedAt, new ItemAtEventArgs<int>(4,0), collection),
 553           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(4, 1), collection),
 554           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 555     }
 556
 557     [Test]
 558     public void RemoveLast()
 559     {
 560       collection.Add(4); collection.Add(56); collection.Add(18);
 561       listen();
 562       collection.RemoveLast();
 563       seen.Check(new CollectionEvent<int>[] {
 564           new CollectionEvent<int>(EventTypeEnum.RemovedAt, new ItemAtEventArgs<int>(18,2), collection),
 565           new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(18, 1), collection),
 566           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 567     }
 568
 569     [Test]
 570     public void Reverse()
 571     {
 572       collection.Add(4); collection.Add(56); collection.Add(8);
 573       listen();
 574       collection.Reverse();
 575       seen.Check(new CollectionEvent<int>[] {
 576           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 577         });
 578       collection.View(1, 0).Reverse();
 579       seen.Check(new CollectionEvent<int>[] { });
 580     }
 581
 582
 583     [Test]
 584     public void Sort()
 585     {
 586       collection.Add(4); collection.Add(56); collection.Add(8);
 587       listen();
 588       collection.Sort();
 589       seen.Check(new CollectionEvent<int>[] {
 590           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 591         });
 592       collection.View(1, 0).Sort();
 593       seen.Check(new CollectionEvent<int>[] { });
 594     }
 595
 596     [Test]
 597     public void Shuffle()
 598     {
 599       collection.Add(4); collection.Add(56); collection.Add(8);
 600       listen();
 601       collection.Shuffle();
 602       seen.Check(new CollectionEvent<int>[] {
 603           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 604         });
 605       collection.View(1, 0).Shuffle();
 606       seen.Check(new CollectionEvent<int>[] { });
 607     }
 608
 609     [Test]
 610     public override void Clear()
 611     {
 612       collection.Add(4); collection.Add(56); collection.Add(18);
 613       listen();
 614       collection.View(1, 1).Clear();
 615       seen.Check(new CollectionEvent<int>[] {
 616           new CollectionEvent<int>(EventTypeEnum.Cleared, new ClearedRangeEventArgs(false,1,1), collection),
 617           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 618         });
 619       collection.Clear();
 620       seen.Check(new CollectionEvent<int>[] {
 621           new CollectionEvent<int>(EventTypeEnum.Cleared, new ClearedRangeEventArgs(true,2,0), collection),
 622           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 623         });
 624       collection.Clear();
 625       seen.Check(new CollectionEvent<int>[] { });
 626     }
 627
 628     [Test]
 629     public void ListDispose()
 630     {
 631       collection.Add(4); collection.Add(56); collection.Add(18);
 632       listen();
 633       collection.View(1, 1).Dispose();
 634       seen.Check(new CollectionEvent<int>[] { });
 635       collection.Dispose();
 636       seen.Check(new CollectionEvent<int>[] {
 637           new CollectionEvent<int>(EventTypeEnum.Cleared, new ClearedRangeEventArgs(true,3,0), collection),
 638           new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 639         });
 640       collection.Dispose();
 641       seen.Check(new CollectionEvent<int>[] { });
 642     }
 643
 644     /*
 645
 646      * /
 647         //[TearDown]
 648         //public void Dispose() { list = null; seen = null; }
 649         /*
 650         [Test]
 651         [ExpectedException(typeof(UnlistenableEventException))]
 652         public void ViewChanged()
 653         {
 654           IList<int> w = collection.View(0, 0);
 655           w.CollectionChanged += new CollectionChangedHandler<int>(w_CollectionChanged);
 656         }
 657
 658         [Test]
 659         [ExpectedException(typeof(UnlistenableEventException))]
 660         public void ViewCleared()
 661         {
 662           IList<int> w = collection.View(0, 0);
 663           w.CollectionCleared += new CollectionClearedHandler<int>(w_CollectionCleared);
 664         }
 665
 666         [Test]
 667         [ExpectedException(typeof(UnlistenableEventException))]
 668         public void ViewAdded()
 669         {
 670           IList<int> w = collection.View(0, 0);
 671           w.ItemsAdded += new ItemsAddedHandler<int>(w_ItemAdded);
 672         }
 673
 674         [Test]
 675         [ExpectedException(typeof(UnlistenableEventException))]
 676         public void ViewInserted()
 677         {
 678           IList<int> w = collection.View(0, 0);
 679           w.ItemInserted += new ItemInsertedHandler<int>(w_ItemInserted);
 680         }
 681
 682         [Test]
 683         [ExpectedException(typeof(UnlistenableEventException))]
 684         public void ViewRemoved()
 685         {
 686           IList<int> w = collection.View(0, 0);
 687           w.ItemsRemoved += new ItemsRemovedHandler<int>(w_ItemRemoved);
 688         }
 689
 690         [Test]
 691         [ExpectedException(typeof(UnlistenableEventException))]
 692         public void ViewRemovedAt()
 693         {
 694           IList<int> w = collection.View(0, 0);
 695           w.ItemRemovedAt += new ItemRemovedAtHandler<int>(w_ItemRemovedAt);
 696         }
 697
 698         void w_CollectionChanged(object sender)
 699         {
 700           throw new NotImplementedException();
 701         }
 702
 703         void w_CollectionCleared(object sender, ClearedEventArgs eventArgs)
 704         {
 705           throw new NotImplementedException();
 706         }
 707
 708         void w_ItemAdded(object sender, ItemCountEventArgs<int> eventArgs)
 709         {
 710           throw new NotImplementedException();
 711         }
 712
 713         void w_ItemInserted(object sender, ItemAtEventArgs<int> eventArgs)
 714         {
 715           throw new NotImplementedException();
 716         }
 717
 718         void w_ItemRemoved(object sender, ItemCountEventArgs<int> eventArgs)
 719         {
 720           throw new NotImplementedException();
 721         }
 722
 723         void w_ItemRemovedAt(object sender, ItemAtEventArgs<int> eventArgs)
 724         {
 725           throw new NotImplementedException();
 726         }*/
 727   }
 728
 729   public class StackTester<U> : CollectionValueTester<U> where U : IStack<int>
 730   {
 731     public override SCG.IEnumerable<EventTypeEnum> GetSpecs()
 732     {
 733       return SpecsBasic;
 734     }
 735
 736     [Test]
 737     public void PushPop()
 738     {
 739       listen();
 740       seen.Check(new CollectionEvent<int>[0]);
 741       collection.Push(23);
 742       seen.Check(new CollectionEvent<int>[] {
 743               new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(23,0), collection),
 744               new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(23, 1), collection),
 745               new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 746       collection.Push(-12);
 747       seen.Check(new CollectionEvent<int>[] {
 748               new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(-12,1), collection),
 749               new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(-12, 1), collection),
 750               new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 751       collection.Pop();
 752       seen.Check(new CollectionEvent<int>[] {
 753               new CollectionEvent<int>(EventTypeEnum.RemovedAt, new ItemAtEventArgs<int>(-12,1), collection),
 754               new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(-12, 1), collection),
 755               new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 756       collection.Pop();
 757       seen.Check(new CollectionEvent<int>[] {
 758               new CollectionEvent<int>(EventTypeEnum.RemovedAt, new ItemAtEventArgs<int>(23,0), collection),
 759               new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(23, 1), collection),
 760               new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 761     }
 762   }
 763
 764   public class QueueTester<U> : CollectionValueTester<U> where U : IQueue<int>
 765   {
 766     public override SCG.IEnumerable<EventTypeEnum> GetSpecs()
 767     {
 768       return SpecsBasic;
 769     }
 770
 771     [Test]
 772     public void EnqueueDequeue()
 773     {
 774       listen();
 775       collection.Enqueue(67);
 776       seen.Check(new CollectionEvent<int>[] {
 777               new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(67,0), collection),
 778               new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(67, 1), collection),
 779               new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 780       collection.Enqueue(2);
 781       seen.Check(new CollectionEvent<int>[] {
 782               new CollectionEvent<int>(EventTypeEnum.Inserted, new ItemAtEventArgs<int>(2,1), collection),
 783               new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(2, 1), collection),
 784               new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 785       collection.Dequeue();
 786       seen.Check(new CollectionEvent<int>[] {
 787               new CollectionEvent<int>(EventTypeEnum.RemovedAt, new ItemAtEventArgs<int>(67,0), collection),
 788               new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(67, 1), collection),
 789               new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 790       collection.Dequeue();
 791       seen.Check(new CollectionEvent<int>[] {
 792               new CollectionEvent<int>(EventTypeEnum.RemovedAt, new ItemAtEventArgs<int>(2,0), collection),
 793               new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(2, 1), collection),
 794               new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)});
 795     }
 796
 797   }
 798
 799   public class PriorityQueueTester<U> : ExtensibleTester<U> where U : IPriorityQueue<int>
 800   {
 801     public override System.Collections.Generic.IEnumerable<EventTypeEnum> GetSpecs()
 802     {
 803       return SpecsBasic;
 804     }
 805
 806     [Test]
 807     public void Direct()
 808     {
 809       listen();
 810       collection.Add(34);
 811       seen.Check(new CollectionEvent<int>[] {
 812         new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(34, 1), collection),
 813         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection),
 814       });
 815       collection.Add(56);
 816       seen.Check(new CollectionEvent<int>[] {
 817         new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(56, 1), collection),
 818         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection),
 819       });
 820       collection.AddAll<int>(new int[] { });
 821       seen.Check(new CollectionEvent<int>[] {
 822       });
 823       collection.Add(34);
 824       seen.Check(new CollectionEvent<int>[] {
 825         new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(34, 1), collection),
 826         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection),
 827       });
 828       collection.Add(12);
 829       seen.Check(new CollectionEvent<int>[] {
 830         new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(12, 1), collection),
 831         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection),
 832       });
 833       collection.DeleteMax();
 834       seen.Check(new CollectionEvent<int>[] {
 835         new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(56, 1), collection),
 836         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection),
 837       });
 838       collection.DeleteMin();
 839       seen.Check(new CollectionEvent<int>[] {
 840         new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(12, 1), collection),
 841         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection),
 842       });
 843       collection.AddAll<int>(new int[] { 4, 5, 6, 2 });
 844       seen.Check(new CollectionEvent<int>[] {
 845         new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(4, 1), collection),
 846         new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(5, 1), collection),
 847         new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(6, 1), collection),
 848         new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(2, 1), collection),
 849         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection)
 850       });
 851     }
 852
 853     [Test]
 854     public void WithHandles()
 855     {
 856       listen();
 857       IPriorityQueueHandle<int> handle = null, handle2;
 858       collection.Add(34);
 859       seen.Check(new CollectionEvent<int>[] {
 860         new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(34, 1), collection),
 861         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection),
 862       });
 863       collection.Add(56);
 864       seen.Check(new CollectionEvent<int>[] {
 865         new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(56, 1), collection),
 866         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection),
 867       });
 868       collection.Add(ref handle, 34);
 869       seen.Check(new CollectionEvent<int>[] {
 870         new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(34, 1), collection),
 871         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection),
 872       });
 873       collection.Add(12);
 874       seen.Check(new CollectionEvent<int>[] {
 875         new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(12, 1), collection),
 876         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection),
 877       });
 878       collection.DeleteMax(out handle2);
 879       seen.Check(new CollectionEvent<int>[] {
 880         new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(56, 1), collection),
 881         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection),
 882       });
 883       collection.DeleteMin(out handle2);
 884       seen.Check(new CollectionEvent<int>[] {
 885         new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(12, 1), collection),
 886         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection),
 887       });
 888
 889       collection.Replace(handle, 117);
 890       seen.Check(new CollectionEvent<int>[] {
 891         new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(34, 1), collection),
 892         new CollectionEvent<int>(EventTypeEnum.Added, new ItemCountEventArgs<int>(117, 1), collection),
 893         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection),
 894       });
 895
 896       collection.Delete(handle);
 897       seen.Check(new CollectionEvent<int>[] {
 898         new CollectionEvent<int>(EventTypeEnum.Removed, new ItemCountEventArgs<int>(117, 1), collection),
 899         new CollectionEvent<int>(EventTypeEnum.Changed, new EventArgs(), collection),
 900       });
 901     }
 902   }
 903
 904   public class DictionaryTester<U> : CollectionValueTester<U, KeyValuePair<int, int>> where U : IDictionary<int, int>
 905   {
 906     public override SCG.IEnumerable<EventTypeEnum> GetSpecs()
 907     {
 908       return SpecsBasic;
 909     }
 910
 911     [Test]
 912     public virtual void Listenable()
 913     {
 914       Assert.AreEqual(EventTypeEnum.Basic, collection.ListenableEvents);
 915       Assert.AreEqual(EventTypeEnum.None, collection.ActiveEvents);
 916       listen();
 917       Assert.AreEqual(listenTo, collection.ActiveEvents);
 918     }
 919
 920     [Test]
 921     public void AddAndREmove()
 922     {
 923       listen();
 924       seen.Check(new CollectionEvent<KeyValuePair<int, int>>[0]);
 925       collection.Add(23, 45);
 926       seen.Check(new CollectionEvent<KeyValuePair<int,int>>[] {
 927           new CollectionEvent<KeyValuePair<int,int>>(EventTypeEnum.Added, new ItemCountEventArgs<KeyValuePair<int,int>>(new KeyValuePair<int,int>(23,45), 1), collection),
 928           new CollectionEvent<KeyValuePair<int,int>>(EventTypeEnum.Changed, new EventArgs(), collection)});
 929       collection.Remove(25);
 930       seen.Check(new CollectionEvent<KeyValuePair<int, int>>[] {
 931           new CollectionEvent<KeyValuePair<int,int>>(EventTypeEnum.Removed, new ItemCountEventArgs<KeyValuePair<int,int>>(new KeyValuePair<int,int>(23,45), 1), collection),
 932           new CollectionEvent<KeyValuePair<int,int>>(EventTypeEnum.Changed, new EventArgs(), collection)});
 933     }
 934
 935
 936
 937   }
 938
 939 }
 940
 941