mcs/class/Mono.C5/Test/hashing/HashTableTests.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 namespace C5UnitTests.hashtable.set\r
  27 {\r
  28   using CollectionOfInt = HashSet<int>;\r
  29 \r
  30   [TestFixture]\r
  31   public class GenericTesters\r
  32   {\r
  33     [Test]\r
  34     public void TestEvents()\r
  35     {\r
  36       Fun<CollectionOfInt> factory = delegate() { return new CollectionOfInt(TenEqualityComparer.Default); };\r
  37       new C5UnitTests.Templates.Events.CollectionTester<CollectionOfInt>().Test(factory);\r
  38     }\r
  39 \r
  40     [Test]\r
  41     public void Extensible()\r
  42     {\r
  43       C5UnitTests.Templates.Extensible.Clone.Tester<CollectionOfInt>();\r
  44       C5UnitTests.Templates.Extensible.Serialization.Tester<CollectionOfInt>();\r
  45     }\r
  46   }\r
  47 \r
  48   static class Factory\r
  49   {\r
  50     public static ICollection<T> New<T>() { return new HashSet<T>(); }\r
  51   }\r
  52 \r
  53 \r
  54   namespace Enumerable\r
  55         {\r
  56                 [TestFixture]\r
  57                 public class Multiops\r
  58                 {\r
  59                         private HashSet<int> list;\r
  60 \r
  61                         private Fun<int, bool> always, never, even;\r
  62 \r
  63 \r
  64                         [SetUp]\r
  65                         public void Init()\r
  66                         {\r
  67                                 list = new HashSet<int>();\r
  68                                 always = delegate{return true;};\r
  69                                 never = delegate{return false;};\r
  70                                 even = delegate(int i){return i%2==0;};\r
  71                         }\r
  72 \r
  73 \r
  74                         [Test]\r
  75                         public void All()\r
  76                         {\r
  77                                 Assert.IsTrue(list.All(always));\r
  78                                 Assert.IsTrue(list.All(never));\r
  79                                 Assert.IsTrue(list.All(even));\r
  80                                 list.Add(0);\r
  81                                 Assert.IsTrue(list.All(always));\r
  82                                 Assert.IsFalse(list.All(never));\r
  83                                 Assert.IsTrue(list.All(even));\r
  84                                 list.Add(5);\r
  85                                 Assert.IsTrue(list.All(always));\r
  86                                 Assert.IsFalse(list.All(never));\r
  87                                 Assert.IsFalse(list.All(even));\r
  88                         }\r
  89 \r
  90 \r
  91                         [Test]\r
  92                         public void Exists()\r
  93                         {\r
  94                                 Assert.IsFalse(list.Exists(always));\r
  95                                 Assert.IsFalse(list.Exists(never));\r
  96                                 Assert.IsFalse(list.Exists(even));\r
  97                                 list.Add(5);\r
  98                                 Assert.IsTrue(list.Exists(always));\r
  99                                 Assert.IsFalse(list.Exists(never));\r
 100                                 Assert.IsFalse(list.Exists(even));\r
 101                                 list.Add(8);\r
 102                                 Assert.IsTrue(list.Exists(always));\r
 103                                 Assert.IsFalse(list.Exists(never));\r
 104                                 Assert.IsTrue(list.Exists(even));\r
 105                         }\r
 106 \r
 107 \r
 108                         [Test]\r
 109                         [Ignore("Temporarily disabled.  2006-03-07.  Martin")]\r
 110                         public void Apply()\r
 111                         {\r
 112                                 int sum = 0;\r
 113                                 Act<int> a = delegate(int i){sum=i+10*sum;};\r
 114 \r
 115                                 list.Apply(a);\r
 116                                 Assert.AreEqual(0, sum);\r
 117                                 sum = 0;\r
 118                                 list.Add(5);list.Add(8);list.Add(7);list.Add(5);\r
 119                                 list.Apply(a);\r
 120                                 Assert.AreEqual(758, sum);\r
 121                         }\r
 122 \r
 123 \r
 124                         [TearDown]\r
 125                         public void Dispose() { list = null; }\r
 126                 }\r
 127 \r
 128 \r
 129 \r
 130                 [TestFixture]\r
 131                 public class GetEnumerator\r
 132                 {\r
 133                         private HashSet<int> hashset;\r
 134 \r
 135 \r
 136                         [SetUp]\r
 137                         public void Init() { hashset = new HashSet<int>(); }\r
 138 \r
 139 \r
 140                         [Test]\r
 141                         public void Empty()\r
 142                         {\r
 143                                 SCG.IEnumerator<int> e = hashset.GetEnumerator();\r
 144 \r
 145                                 Assert.IsFalse(e.MoveNext());\r
 146                         }\r
 147 \r
 148 \r
 149                         [Test]\r
 150                         public void Normal()\r
 151                         {\r
 152                                 hashset.Add(5);\r
 153                                 hashset.Add(8);\r
 154                                 hashset.Add(5);\r
 155                                 hashset.Add(5);\r
 156                                 hashset.Add(10);\r
 157                                 hashset.Add(1);\r
 158                                 hashset.Add(16);\r
 159                                 hashset.Add(18);\r
 160                                 hashset.Add(17);\r
 161                                 hashset.Add(33);\r
 162                                 Assert.IsTrue(IC.seteq(hashset, 1, 5, 8, 10, 16, 17, 18, 33));\r
 163                         }\r
 164 \r
 165                         [Test]\r
 166                         public void DoDispose()\r
 167                         {\r
 168                                 hashset.Add(5);\r
 169                                 hashset.Add(8);\r
 170                                 hashset.Add(5);\r
 171 \r
 172                                 SCG.IEnumerator<int> e = hashset.GetEnumerator();\r
 173 \r
 174                                 e.MoveNext();\r
 175                                 e.MoveNext();\r
 176                                 e.Dispose();\r
 177                         }\r
 178 \r
 179 \r
 180                         [Test]\r
 181       [ExpectedException(typeof(CollectionModifiedException))]\r
 182       public void MoveNextAfterUpdate()\r
 183                         {\r
 184                                 hashset.Add(5);\r
 185                                 hashset.Add(8);\r
 186                                 hashset.Add(5);\r
 187 \r
 188                                 SCG.IEnumerator<int> e = hashset.GetEnumerator();\r
 189 \r
 190                                 e.MoveNext();\r
 191                                 hashset.Add(99);\r
 192                                 e.MoveNext();\r
 193                         }\r
 194 \r
 195 \r
 196                         [TearDown]\r
 197                         public void Dispose() { hashset = null; }\r
 198                 }\r
 199         }\r
 200 \r
 201         namespace CollectionOrSink\r
 202         {\r
 203     [TestFixture]\r
 204     public class Formatting\r
 205     {\r
 206       ICollection<int> coll;\r
 207       IFormatProvider rad16;\r
 208       [SetUp]\r
 209       public void Init() { coll = Factory.New<int>(); rad16 = new RadixFormatProvider(16); }\r
 210       [TearDown]\r
 211       public void Dispose() { coll = null; rad16 = null; }\r
 212       [Test]\r
 213       [Ignore("Temporarily disabled.  2006-03-07.  Martin")]\r
 214       public void Format()\r
 215       {\r
 216         Assert.AreEqual("{  }", coll.ToString());\r
 217         coll.AddAll<int>(new int[] { -4, 28, 129, 65530 });\r
 218         Assert.AreEqual("{ 65530, -4, 28, 129 }", coll.ToString());\r
 219         Assert.AreEqual("{ FFFA, -4, 1C, 81 }", coll.ToString(null, rad16));\r
 220         Assert.AreEqual("{ 65530, -4, ... }", coll.ToString("L14", null));\r
 221         Assert.AreEqual("{ FFFA, -4, ... }", coll.ToString("L14", rad16));\r
 222       }\r
 223     }\r
 224 \r
 225     [TestFixture]\r
 226     public class CollectionOrSink\r
 227                 {\r
 228                         private HashSet<int> hashset;\r
 229 \r
 230 \r
 231                         [SetUp]\r
 232                         public void Init() { hashset = new HashSet<int>(); }\r
 233 \r
 234       [Test]\r
 235       public void Choose()\r
 236       {\r
 237         hashset.Add(7);\r
 238         Assert.AreEqual(7, hashset.Choose());\r
 239       }\r
 240 \r
 241       [Test]\r
 242       [ExpectedException(typeof(NoSuchItemException))]\r
 243       public void BadChoose()\r
 244       {\r
 245         hashset.Choose();\r
 246       }\r
 247 \r
 248       [Test]\r
 249       public void CountEtAl()\r
 250                         {\r
 251                                 Assert.AreEqual(0, hashset.Count);\r
 252                                 Assert.IsTrue(hashset.IsEmpty);\r
 253                                 Assert.IsFalse(hashset.AllowsDuplicates);\r
 254                                 Assert.IsTrue(hashset.Add(0));\r
 255                                 Assert.AreEqual(1, hashset.Count);\r
 256                                 Assert.IsFalse(hashset.IsEmpty);\r
 257                                 Assert.IsTrue(hashset.Add(5));\r
 258                                 Assert.AreEqual(2, hashset.Count);\r
 259                                 Assert.IsFalse(hashset.Add(5));\r
 260                                 Assert.AreEqual(2, hashset.Count);\r
 261                                 Assert.IsFalse(hashset.IsEmpty);\r
 262                                 Assert.IsTrue(hashset.Add(8));\r
 263                                 Assert.AreEqual(3, hashset.Count);\r
 264                         }\r
 265 \r
 266 \r
 267                         [Test]\r
 268                         public void AddAll()\r
 269                         {\r
 270                                 hashset.Add(3);hashset.Add(4);hashset.Add(5);\r
 271 \r
 272                                 HashSet<int> hashset2 = new HashSet<int>();\r
 273 \r
 274                                 hashset2.AddAll(hashset);\r
 275                                 Assert.IsTrue(IC.seteq(hashset2, 3, 4, 5));\r
 276                                 hashset.Add(9);\r
 277                                 hashset.AddAll(hashset2);\r
 278                                 Assert.IsTrue(IC.seteq(hashset2, 3, 4, 5));\r
 279                                 Assert.IsTrue(IC.seteq(hashset, 3, 4, 5, 9));\r
 280                         }\r
 281 \r
 282 \r
 283                         [TearDown]\r
 284                         public void Dispose() { hashset = null; }\r
 285                 }\r
 286 \r
 287     [TestFixture]\r
 288     public class FindPredicate\r
 289     {\r
 290       private HashSet<int> list;\r
 291       Fun<int, bool> pred;\r
 292 \r
 293       [SetUp]\r
 294       public void Init()\r
 295       {\r
 296         list = new HashSet<int>(TenEqualityComparer.Default);\r
 297         pred = delegate(int i) { return i % 5 == 0; };\r
 298       }\r
 299 \r
 300       [TearDown]\r
 301       public void Dispose() { list = null; }\r
 302 \r
 303       [Test]\r
 304       [Ignore("Temporarily disabled.  2006-03-07.  Martin")]\r
 305       public void Find()\r
 306       {\r
 307         int i;\r
 308         Assert.IsFalse(list.Find(pred, out i));\r
 309         list.AddAll<int>(new int[] { 4, 22, 67, 37 });\r
 310         Assert.IsFalse(list.Find(pred, out i));\r
 311         list.AddAll<int>(new int[] { 45, 122, 675, 137 });\r
 312         Assert.IsTrue(list.Find(pred, out i));\r
 313         Assert.AreEqual(45, i);\r
 314       }\r
 315     }\r
 316 \r
 317     [TestFixture]\r
 318     public class UniqueItems\r
 319     {\r
 320       private HashSet<int> list;\r
 321 \r
 322       [SetUp]\r
 323       public void Init() { list = new HashSet<int>(); }\r
 324 \r
 325       [TearDown]\r
 326       public void Dispose() { list = null; }\r
 327 \r
 328       [Test]\r
 329       public void Test()\r
 330       {\r
 331         Assert.IsTrue(IC.seteq(list.UniqueItems()));\r
 332         Assert.IsTrue(IC.seteq(list.ItemMultiplicities()));\r
 333         list.AddAll<int>(new int[] { 7, 9, 7 });\r
 334         Assert.IsTrue(IC.seteq(list.UniqueItems(), 7, 9));\r
 335         Assert.IsTrue(IC.seteq(list.ItemMultiplicities(), 7, 1, 9, 1));\r
 336       }\r
 337     }\r
 338 \r
 339     [TestFixture]\r
 340     public class ArrayTest\r
 341                 {\r
 342                         private HashSet<int> hashset;\r
 343 \r
 344                         int[] a;\r
 345 \r
 346 \r
 347                         [SetUp]\r
 348                         public void Init()\r
 349                         {\r
 350                                 hashset = new HashSet<int>();\r
 351                                 a = new int[10];\r
 352                                 for (int i = 0; i < 10; i++)\r
 353                                         a[i] = 1000 + i;\r
 354                         }\r
 355 \r
 356 \r
 357                         [TearDown]\r
 358                         public void Dispose() { hashset = null; }\r
 359 \r
 360 \r
 361                         private string aeq(int[] a, params int[] b)\r
 362                         {\r
 363                                 if (a.Length != b.Length)\r
 364                                         return "Lengths differ: " + a.Length + " != " + b.Length;\r
 365 \r
 366                                 for (int i = 0; i < a.Length; i++)\r
 367                                         if (a[i] != b[i])\r
 368                                                 return String.Format("{0}'th elements differ: {1} != {2}", i, a[i], b[i]);\r
 369 \r
 370                                 return "Alles klar";\r
 371                         }\r
 372 \r
 373 \r
 374                         [Test]\r
 375                         public void ToArray()\r
 376                         {\r
 377                                 Assert.AreEqual("Alles klar", aeq(hashset.ToArray()));\r
 378                                 hashset.Add(7);\r
 379                                 hashset.Add(3);\r
 380                                 hashset.Add(10);\r
 381 \r
 382                                 int[] r = hashset.ToArray();\r
 383 \r
 384                                 Array.Sort(r);\r
 385                                 Assert.AreEqual("Alles klar", aeq(r, 3, 7, 10));\r
 386                         }\r
 387 \r
 388 \r
 389                         [Test]\r
 390                         [Ignore("Temporarily disabled.  2006-03-07.  Martin")]\r
 391                         public void CopyTo()\r
 392                         {\r
 393                                 //Note: for small ints the itemequalityComparer is the identity!\r
 394                                 hashset.CopyTo(a, 1);\r
 395                                 Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009));\r
 396                                 hashset.Add(6);\r
 397                                 hashset.CopyTo(a, 2);\r
 398                                 Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 6, 1003, 1004, 1005, 1006, 1007, 1008, 1009));\r
 399                                 hashset.Add(4);\r
 400                                 hashset.Add(9);\r
 401                                 hashset.CopyTo(a, 4);\r
 402 \r
 403                                 //TODO: make test independent on onterequalityComparer\r
 404                                 Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 6, 1003, 6, 9, 4, 1007, 1008, 1009));\r
 405                                 hashset.Clear();\r
 406                                 hashset.Add(7);\r
 407                                 hashset.CopyTo(a, 9);\r
 408                                 Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 6, 1003, 6, 9, 4, 1007, 1008, 7));\r
 409                         }\r
 410 \r
 411 \r
 412                         [Test]\r
 413       [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
 414       public void CopyToBad()\r
 415                         {\r
 416                                 hashset.CopyTo(a, 11);\r
 417                         }\r
 418 \r
 419 \r
 420                         [Test]\r
 421                         [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
 422                         public void CopyToBad2()\r
 423                         {\r
 424                                 hashset.CopyTo(a, -1);\r
 425                         }\r
 426 \r
 427 \r
 428                         [Test]\r
 429       [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
 430       public void CopyToTooFar()\r
 431                         {\r
 432                                 hashset.Add(3);\r
 433                                 hashset.Add(8);\r
 434                                 hashset.CopyTo(a, 9);\r
 435                         }\r
 436                 }\r
 437 \r
 438 \r
 439 \r
 440                 [TestFixture]\r
 441                 public class Sync\r
 442                 {\r
 443                         private HashSet<int> list;\r
 444 \r
 445 \r
 446                         [SetUp]\r
 447                         public void Init()\r
 448                         {\r
 449                                 list = new HashSet<int>();\r
 450                         }\r
 451 \r
 452 \r
 453                         [TearDown]\r
 454                         public void Dispose() { list = null; }\r
 455 \r
 456 \r
 457                         [Test]\r
 458                         public void Get()\r
 459                         {\r
 460                                 Assert.IsNotNull(list.SyncRoot);\r
 461                         }\r
 462                 }\r
 463         }\r
 464 \r
 465 \r
 466 \r
 467 \r
 468         namespace EditableCollection\r
 469         {\r
 470                 [TestFixture]\r
 471                 public class Collision\r
 472                 {\r
 473                         HashSet<int> hashset;\r
 474 \r
 475 \r
 476                         [SetUp]\r
 477                         public void Init()\r
 478                         {\r
 479                                 hashset = new HashSet<int>();\r
 480                         }\r
 481 \r
 482 \r
 483                         [Test]\r
 484                         public void SingleCollision()\r
 485                         {\r
 486                                 hashset.Add(7);\r
 487                                 hashset.Add(7 - 1503427877);\r
 488 \r
 489                                 //foreach (int cell in hashset) Console.WriteLine("A: {0}", cell);\r
 490                                 hashset.Remove(7);\r
 491                                 Assert.IsTrue(hashset.Contains(7 - 1503427877));\r
 492                         }\r
 493 \r
 494 \r
 495                         [TearDown]\r
 496                         public void Dispose()\r
 497                         {\r
 498                                 hashset = null;\r
 499                         }\r
 500                 }\r
 501 \r
 502 \r
 503 \r
 504                 [TestFixture]\r
 505                 public class Searching\r
 506                 {\r
 507                         private HashSet<int> hashset;\r
 508 \r
 509 \r
 510                         [SetUp]\r
 511                         public void Init() { hashset = new HashSet<int>(); }\r
 512 \r
 513 \r
 514       [Test]\r
 515       [ExpectedException(typeof(NullReferenceException))]\r
 516       public void NullEqualityComparerinConstructor1()\r
 517       {\r
 518         new HashSet<int>(null);\r
 519       }\r
 520 \r
 521       [Test]\r
 522       [ExpectedException(typeof(NullReferenceException))]\r
 523       public void NullEqualityComparerinConstructor2()\r
 524       {\r
 525         new HashSet<int>(5, null);\r
 526       }\r
 527 \r
 528       [Test]\r
 529       [ExpectedException(typeof(NullReferenceException))]\r
 530       public void NullEqualityComparerinConstructor3()\r
 531       {\r
 532         new HashSet<int>(5, 0.5, null);\r
 533       }\r
 534 \r
 535       [Test]\r
 536                         public void Contains()\r
 537                         {\r
 538                                 Assert.IsFalse(hashset.Contains(5));\r
 539                                 hashset.Add(5);\r
 540                                 Assert.IsTrue(hashset.Contains(5));\r
 541                                 Assert.IsFalse(hashset.Contains(7));\r
 542                                 hashset.Add(8);\r
 543                                 hashset.Add(10);\r
 544                                 Assert.IsTrue(hashset.Contains(5));\r
 545                                 Assert.IsFalse(hashset.Contains(7));\r
 546                                 Assert.IsTrue(hashset.Contains(8));\r
 547                                 Assert.IsTrue(hashset.Contains(10));\r
 548                                 hashset.Remove(8);\r
 549                                 Assert.IsTrue(hashset.Contains(5));\r
 550                                 Assert.IsFalse(hashset.Contains(7));\r
 551                                 Assert.IsFalse(hashset.Contains(8));\r
 552                                 Assert.IsTrue(hashset.Contains(10));\r
 553                                 hashset.Add(0);hashset.Add(16);hashset.Add(32);hashset.Add(48);hashset.Add(64);\r
 554                                 Assert.IsTrue(hashset.Contains(0));\r
 555                                 Assert.IsTrue(hashset.Contains(16));\r
 556                                 Assert.IsTrue(hashset.Contains(32));\r
 557                                 Assert.IsTrue(hashset.Contains(48));\r
 558                                 Assert.IsTrue(hashset.Contains(64));\r
 559                                 Assert.IsTrue(hashset.Check());\r
 560 \r
 561                                 int i = 0, j = i;\r
 562 \r
 563                                 Assert.IsTrue(hashset.Find(ref i));\r
 564                                 Assert.AreEqual(j, i);\r
 565                                 j = i = 16;\r
 566                                 Assert.IsTrue(hashset.Find(ref i));\r
 567                                 Assert.AreEqual(j, i);\r
 568                                 j = i = 32;\r
 569                                 Assert.IsTrue(hashset.Find(ref i));\r
 570                                 Assert.AreEqual(j, i);\r
 571                                 j = i = 48;\r
 572                                 Assert.IsTrue(hashset.Find(ref i));\r
 573                                 Assert.AreEqual(j, i);\r
 574                                 j = i = 64;\r
 575                                 Assert.IsTrue(hashset.Find(ref i));\r
 576                                 Assert.AreEqual(j, i);\r
 577                                 j = i = 80;\r
 578                                 Assert.IsFalse(hashset.Find(ref i));\r
 579                                 Assert.AreEqual(j, i);\r
 580                         }\r
 581 \r
 582 \r
 583                         [Test]\r
 584                         public void Many()\r
 585                         {\r
 586                                 int j = 7373;\r
 587                                 int[] a = new int[j];\r
 588 \r
 589                                 for (int i = 0; i < j; i++)\r
 590                                 {\r
 591                                         hashset.Add(3 * i + 1);\r
 592                                         a[i] = 3 * i + 1;\r
 593                                 }\r
 594 \r
 595                                 Assert.IsTrue(IC.seteq(hashset, a));\r
 596                         }\r
 597 \r
 598 \r
 599                         [Test]\r
 600                         public void ContainsCount()\r
 601                         {\r
 602                                 Assert.AreEqual(0, hashset.ContainsCount(5));\r
 603                                 hashset.Add(5);\r
 604                                 Assert.AreEqual(1, hashset.ContainsCount(5));\r
 605                                 Assert.AreEqual(0, hashset.ContainsCount(7));\r
 606                                 hashset.Add(8);\r
 607                                 Assert.AreEqual(1, hashset.ContainsCount(5));\r
 608                                 Assert.AreEqual(0, hashset.ContainsCount(7));\r
 609                                 Assert.AreEqual(1, hashset.ContainsCount(8));\r
 610                                 hashset.Add(5);\r
 611                                 Assert.AreEqual(1, hashset.ContainsCount(5));\r
 612                                 Assert.AreEqual(0, hashset.ContainsCount(7));\r
 613                                 Assert.AreEqual(1, hashset.ContainsCount(8));\r
 614                         }\r
 615 \r
 616 \r
 617                         [Test]\r
 618                         [Ignore("Temporarily disabled.  2006-03-07.  Martin")]\r
 619                         public void RemoveAllCopies()\r
 620                         {\r
 621                                 hashset.Add(5);hashset.Add(7);hashset.Add(5);\r
 622                                 Assert.AreEqual(1, hashset.ContainsCount(5));\r
 623                                 Assert.AreEqual(1, hashset.ContainsCount(7));\r
 624                                 hashset.RemoveAllCopies(5);\r
 625                                 Assert.AreEqual(0, hashset.ContainsCount(5));\r
 626                                 Assert.AreEqual(1, hashset.ContainsCount(7));\r
 627                                 hashset.Add(5);hashset.Add(8);hashset.Add(5);\r
 628                                 hashset.RemoveAllCopies(8);\r
 629                                 Assert.IsTrue(IC.eq(hashset, 7, 5));\r
 630                         }\r
 631 \r
 632 \r
 633                         [Test]\r
 634                         public void ContainsAll()\r
 635                         {\r
 636                                 HashSet<int> list2 = new HashSet<int>();\r
 637 \r
 638                                 Assert.IsTrue(hashset.ContainsAll(list2));\r
 639                                 list2.Add(4);\r
 640                                 Assert.IsFalse(hashset.ContainsAll(list2));\r
 641                                 hashset.Add(4);\r
 642                                 Assert.IsTrue(hashset.ContainsAll(list2));\r
 643                                 hashset.Add(5);\r
 644                                 Assert.IsTrue(hashset.ContainsAll(list2));\r
 645                                 list2.Add(20);\r
 646                                 Assert.IsFalse(hashset.ContainsAll(list2));\r
 647                                 hashset.Add(20);\r
 648                                 Assert.IsTrue(hashset.ContainsAll(list2));\r
 649                         }\r
 650 \r
 651 \r
 652                         [Test]\r
 653                         public void RetainAll()\r
 654                         {\r
 655                                 HashSet<int> list2 = new HashSet<int>();\r
 656 \r
 657                                 hashset.Add(4);hashset.Add(5);hashset.Add(6);\r
 658                                 list2.Add(5);list2.Add(4);list2.Add(7);\r
 659                                 hashset.RetainAll(list2);\r
 660                                 Assert.IsTrue(IC.seteq(hashset, 4, 5));\r
 661                                 hashset.Add(6);\r
 662                                 list2.Clear();\r
 663                                 list2.Add(7);list2.Add(8);list2.Add(9);\r
 664                                 hashset.RetainAll(list2);\r
 665                                 Assert.IsTrue(IC.seteq(hashset));\r
 666                         }\r
 667 \r
 668 \r
 669                         [Test]\r
 670                         public void RemoveAll()\r
 671                         {\r
 672                                 HashSet<int> list2 = new HashSet<int>();\r
 673 \r
 674                                 hashset.Add(4);hashset.Add(5);hashset.Add(6);\r
 675                                 list2.Add(5);list2.Add(7);list2.Add(4);\r
 676                                 hashset.RemoveAll(list2);\r
 677                                 Assert.IsTrue(IC.eq(hashset, 6));\r
 678                                 hashset.Add(5);hashset.Add(4);\r
 679                                 list2.Clear();\r
 680                                 list2.Add(6);list2.Add(5);\r
 681                                 hashset.RemoveAll(list2);\r
 682                                 Assert.IsTrue(IC.eq(hashset, 4));\r
 683                                 list2.Clear();\r
 684                                 list2.Add(7);list2.Add(8);list2.Add(9);\r
 685                                 hashset.RemoveAll(list2);\r
 686                                 Assert.IsTrue(IC.eq(hashset, 4));\r
 687                         }\r
 688 \r
 689 \r
 690                         [Test]\r
 691                         public void Remove()\r
 692                         {\r
 693                                 hashset.Add(4);hashset.Add(4);hashset.Add(5);hashset.Add(4);hashset.Add(6);\r
 694                                 Assert.IsFalse(hashset.Remove(2));\r
 695                                 Assert.IsTrue(hashset.Remove(4));\r
 696                                 Assert.IsTrue(IC.seteq(hashset, 5, 6));\r
 697                                 hashset.Add(7);\r
 698                                 hashset.Add(21);hashset.Add(37);hashset.Add(53);hashset.Add(69);hashset.Add(85);\r
 699                                 Assert.IsTrue(hashset.Remove(5));\r
 700                                 Assert.IsTrue(IC.seteq(hashset, 6, 7, 21, 37, 53, 69, 85));\r
 701                                 Assert.IsFalse(hashset.Remove(165));\r
 702                                 Assert.IsTrue(IC.seteq(hashset, 6, 7, 21, 37, 53, 69, 85));\r
 703                                 Assert.IsTrue(hashset.Remove(53));\r
 704                                 Assert.IsTrue(IC.seteq(hashset, 6, 7, 21, 37, 69, 85));\r
 705                                 Assert.IsTrue(hashset.Remove(37));\r
 706                                 Assert.IsTrue(IC.seteq(hashset, 6, 7, 21, 69, 85));\r
 707                                 Assert.IsTrue(hashset.Remove(85));\r
 708                                 Assert.IsTrue(IC.seteq(hashset, 6, 7, 21, 69));\r
 709                         }\r
 710 \r
 711 \r
 712                         [Test]\r
 713                         public void Clear()\r
 714                         {\r
 715                                 hashset.Add(7);hashset.Add(7);\r
 716                                 hashset.Clear();\r
 717                                 Assert.IsTrue(hashset.IsEmpty);\r
 718                         }\r
 719 \r
 720 \r
 721                         [TearDown]\r
 722                         public void Dispose() { hashset = null; }\r
 723                 }\r
 724 \r
 725                 [TestFixture]\r
 726                 public class Combined\r
 727                 {\r
 728                         private ICollection<KeyValuePair<int,int>> lst;\r
 729 \r
 730 \r
 731                         [SetUp]\r
 732                         public void Init()\r
 733                         {\r
 734                 lst = new HashSet<KeyValuePair<int, int>>(new KeyValuePairEqualityComparer<int, int>());\r
 735                 for (int i = 0; i < 10; i++)\r
 736                                         lst.Add(new KeyValuePair<int,int>(i, i + 30));\r
 737                         }\r
 738 \r
 739 \r
 740                         [TearDown]\r
 741                         public void Dispose() { lst = null; }\r
 742 \r
 743 \r
 744                         [Test]\r
 745                         public void Find()\r
 746                         {\r
 747                                 KeyValuePair<int,int> p = new KeyValuePair<int,int>(3, 78);\r
 748 \r
 749                                 Assert.IsTrue(lst.Find(ref p));\r
 750                                 Assert.AreEqual(3, p.Key);\r
 751                                 Assert.AreEqual(33, p.Value);\r
 752                                 p = new KeyValuePair<int,int>(13, 78);\r
 753                                 Assert.IsFalse(lst.Find(ref p));\r
 754                         }\r
 755 \r
 756 \r
 757                         [Test]\r
 758                         public void FindOrAdd()\r
 759                         {\r
 760                                 KeyValuePair<int,int> p = new KeyValuePair<int,int>(3, 78);\r
 761                                 KeyValuePair<int,int> q = new KeyValuePair<int,int>();\r
 762 \r
 763                                 Assert.IsTrue(lst.FindOrAdd(ref p));\r
 764                                 Assert.AreEqual(3, p.Key);\r
 765                                 Assert.AreEqual(33, p.Value);\r
 766                                 p = new KeyValuePair<int,int>(13, 79);\r
 767                                 Assert.IsFalse(lst.FindOrAdd(ref p));\r
 768                                 q.Key = 13;\r
 769                                 Assert.IsTrue(lst.Find(ref q));\r
 770                                 Assert.AreEqual(13, q.Key);\r
 771                                 Assert.AreEqual(79, q.Value);\r
 772                         }\r
 773 \r
 774 \r
 775                         [Test]\r
 776                         public void Update()\r
 777                         {\r
 778                                 KeyValuePair<int,int> p = new KeyValuePair<int,int>(3, 78);\r
 779                                 KeyValuePair<int,int> q = new KeyValuePair<int,int>();\r
 780 \r
 781                                 Assert.IsTrue(lst.Update(p));\r
 782                                 q.Key = 3;\r
 783                                 Assert.IsTrue(lst.Find(ref q));\r
 784                                 Assert.AreEqual(3, q.Key);\r
 785                                 Assert.AreEqual(78, q.Value);\r
 786                                 p = new KeyValuePair<int,int>(13, 78);\r
 787                                 Assert.IsFalse(lst.Update(p));\r
 788                         }\r
 789 \r
 790 \r
 791                         [Test]\r
 792                         public void UpdateOrAdd()\r
 793                         {\r
 794                                 KeyValuePair<int,int> p = new KeyValuePair<int,int>(3, 78);\r
 795                                 KeyValuePair<int,int> q = new KeyValuePair<int,int>();\r
 796 \r
 797                                 Assert.IsTrue(lst.UpdateOrAdd(p));\r
 798                                 q.Key = 3;\r
 799                                 Assert.IsTrue(lst.Find(ref q));\r
 800                                 Assert.AreEqual(3, q.Key);\r
 801                                 Assert.AreEqual(78, q.Value);\r
 802                                 p = new KeyValuePair<int,int>(13, 79);\r
 803                                 Assert.IsFalse(lst.UpdateOrAdd(p));\r
 804                                 q.Key = 13;\r
 805                                 Assert.IsTrue(lst.Find(ref q));\r
 806                                 Assert.AreEqual(13, q.Key);\r
 807                                 Assert.AreEqual(79, q.Value);\r
 808                         }\r
 809 \r
 810 \r
 811                         [Test]\r
 812                         public void RemoveWithReturn()\r
 813                         {\r
 814                                 KeyValuePair<int,int> p = new KeyValuePair<int,int>(3, 78);\r
 815                                 //KeyValuePair<int,int> q = new KeyValuePair<int,int>();\r
 816 \r
 817                 Assert.IsTrue(lst.Remove(p, out p));\r
 818                 Assert.AreEqual(3, p.Key);\r
 819                                 Assert.AreEqual(33, p.Value);\r
 820                                 p = new KeyValuePair<int,int>(13, 78);\r
 821                 Assert.IsFalse(lst.Remove(p, out p));\r
 822             }\r
 823                 }\r
 824 \r
 825 \r
 826         }\r
 827 \r
 828 \r
 829 \r
 830 \r
 831         namespace HashingAndEquals\r
 832         {\r
 833                 [TestFixture]\r
 834                 public class IEditableCollection\r
 835                 {\r
 836                         private ICollection<int> dit, dat, dut;\r
 837 \r
 838 \r
 839                         [SetUp]\r
 840                         public void Init()\r
 841                         {\r
 842                                 dit = new HashSet<int>();\r
 843                                 dat = new HashSet<int>();\r
 844                                 dut = new HashSet<int>();\r
 845                         }\r
 846 \r
 847 \r
 848                         [Test]\r
 849                         public void EmptyEmpty()\r
 850                         {\r
 851                                 Assert.IsTrue(dit.UnsequencedEquals(dat));\r
 852                         }\r
 853 \r
 854 \r
 855                         [Test]\r
 856                         public void EmptyNonEmpty()\r
 857                         {\r
 858                                 dit.Add(3);\r
 859                                 Assert.IsFalse(dit.UnsequencedEquals(dat));\r
 860                                 Assert.IsFalse(dat.UnsequencedEquals(dit));\r
 861                         }\r
 862 \r
 863 \r
 864                         [Test]\r
 865                         public void HashVal()\r
 866                         {\r
 867                 Assert.AreEqual(CHC.unsequencedhashcode(), dit.GetUnsequencedHashCode());\r
 868                 dit.Add(3);\r
 869                 Assert.AreEqual(CHC.unsequencedhashcode(3), dit.GetUnsequencedHashCode());\r
 870                 dit.Add(7);\r
 871                 Assert.AreEqual(CHC.unsequencedhashcode(3, 7), dit.GetUnsequencedHashCode());\r
 872                 Assert.AreEqual(CHC.unsequencedhashcode(), dut.GetUnsequencedHashCode());\r
 873                 dut.Add(3);\r
 874                 Assert.AreEqual(CHC.unsequencedhashcode(3), dut.GetUnsequencedHashCode());\r
 875                 dut.Add(7);\r
 876                 Assert.AreEqual(CHC.unsequencedhashcode(7, 3), dut.GetUnsequencedHashCode());\r
 877             }\r
 878 \r
 879 \r
 880                         [Test]\r
 881                         public void EqualHashButDifferent()\r
 882                         {\r
 883                                 dit.Add(-1657792980);dit.Add(-1570288808);\r
 884                                 dat.Add(1862883298);dat.Add(-272461342);\r
 885                                 Assert.AreEqual(dit.GetUnsequencedHashCode(), dat.GetUnsequencedHashCode());\r
 886                                 Assert.IsFalse(dit.UnsequencedEquals(dat));\r
 887                         }\r
 888 \r
 889 \r
 890                         [Test]\r
 891                         public void Normal()\r
 892                         {\r
 893                                 dit.Add(3);\r
 894                                 dit.Add(7);\r
 895                                 dat.Add(3);\r
 896                                 Assert.IsFalse(dit.UnsequencedEquals(dat));\r
 897                                 Assert.IsFalse(dat.UnsequencedEquals(dit));\r
 898                                 dat.Add(7);\r
 899                                 Assert.IsTrue(dit.UnsequencedEquals(dat));\r
 900                                 Assert.IsTrue(dat.UnsequencedEquals(dit));\r
 901                         }\r
 902 \r
 903 \r
 904                         [Test]\r
 905                         public void WrongOrder()\r
 906                         {\r
 907                                 dit.Add(3);\r
 908                                 dut.Add(3);\r
 909                                 Assert.IsTrue(dit.UnsequencedEquals(dut));\r
 910                                 Assert.IsTrue(dut.UnsequencedEquals(dit));\r
 911                                 dit.Add(7);\r
 912                                 dut.Add(7);\r
 913                                 Assert.IsTrue(dit.UnsequencedEquals(dut));\r
 914                                 Assert.IsTrue(dut.UnsequencedEquals(dit));\r
 915                         }\r
 916 \r
 917 \r
 918                         [Test]\r
 919                         public void Reflexive()\r
 920                         {\r
 921                                 Assert.IsTrue(dit.UnsequencedEquals(dit));\r
 922                                 dit.Add(3);\r
 923                                 Assert.IsTrue(dit.UnsequencedEquals(dit));\r
 924                                 dit.Add(7);\r
 925                                 Assert.IsTrue(dit.UnsequencedEquals(dit));\r
 926                         }\r
 927 \r
 928 \r
 929                         [TearDown]\r
 930                         public void Dispose()\r
 931                         {\r
 932                                 dit = null;\r
 933                                 dat = null;\r
 934                                 dut = null;\r
 935                         }\r
 936                 }\r
 937 \r
 938 \r
 939 \r
 940                 [TestFixture]\r
 941                 public class MultiLevelUnorderedOfUnOrdered\r
 942                 {\r
 943                         private ICollection<int> dit, dat, dut;\r
 944 \r
 945                         private ICollection<ICollection<int>> Dit, Dat, Dut;\r
 946 \r
 947 \r
 948                         [SetUp]\r
 949                         public void Init()\r
 950                         {\r
 951                                 dit = new HashSet<int>();\r
 952                                 dat = new HashSet<int>();\r
 953                                 dut = new HashSet<int>();\r
 954                                 dit.Add(2);dit.Add(1);\r
 955                                 dat.Add(1);dat.Add(2);\r
 956                                 dut.Add(3);\r
 957                                 Dit = new HashSet<ICollection<int>>();\r
 958                                 Dat = new HashSet<ICollection<int>>();\r
 959                                 Dut = new HashSet<ICollection<int>>();\r
 960                         }\r
 961 \r
 962 \r
 963                         [Test]\r
 964                         public void Check()\r
 965                         {\r
 966                                 Assert.IsTrue(dit.UnsequencedEquals(dat));\r
 967                                 Assert.IsFalse(dit.UnsequencedEquals(dut));\r
 968                         }\r
 969 \r
 970 \r
 971                         [Test]\r
 972                         public void Multi()\r
 973                         {\r
 974                                 Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
 975                                 Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
 976                                 Assert.IsTrue(Dit.UnsequencedEquals(Dat));\r
 977                                 Assert.IsFalse(Dit.UnsequencedEquals(Dut));\r
 978                         }\r
 979 \r
 980 \r
 981                         [TearDown]\r
 982                         public void Dispose()\r
 983                         {\r
 984                                 dit = dat = dut = null;\r
 985                                 Dit = Dat = Dut = null;\r
 986                         }\r
 987                 }\r
 988 \r
 989 \r
 990 \r
 991                 [TestFixture]\r
 992                 public class MultiLevelOrderedOfUnOrdered\r
 993                 {\r
 994                         private ICollection<int> dit, dat, dut;\r
 995 \r
 996                         private ISequenced<ICollection<int>> Dit, Dat, Dut;\r
 997 \r
 998 \r
 999                         [SetUp]\r
1000                         public void Init()\r
1001                         {\r
1002                                 dit = new HashSet<int>();\r
1003                                 dat = new HashSet<int>();\r
1004                                 dut = new HashSet<int>();\r
1005                                 dit.Add(2);dit.Add(1);\r
1006                                 dat.Add(1);dat.Add(2);\r
1007                                 dut.Add(3);\r
1008                                 Dit = new LinkedList<ICollection<int>>();\r
1009                                 Dat = new LinkedList<ICollection<int>>();\r
1010                                 Dut = new LinkedList<ICollection<int>>();\r
1011                         }\r
1012 \r
1013 \r
1014                         [Test]\r
1015                         public void Check()\r
1016                         {\r
1017                                 Assert.IsTrue(dit.UnsequencedEquals(dat));\r
1018                                 Assert.IsFalse(dit.UnsequencedEquals(dut));\r
1019                         }\r
1020 \r
1021 \r
1022                         [Test]\r
1023                         public void Multi()\r
1024                         {\r
1025                                 Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
1026                                 Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
1027                                 Dut.Add(dit);Dut.Add(dut);Dut.Add(dat);\r
1028                                 Assert.IsFalse(Dit.SequencedEquals(Dat));\r
1029                                 Assert.IsTrue(Dit.SequencedEquals(Dut));\r
1030                         }\r
1031 \r
1032 \r
1033                         [TearDown]\r
1034                         public void Dispose()\r
1035                         {\r
1036                                 dit = dat = dut = null;\r
1037                                 Dit = Dat = Dut = null;\r
1038                         }\r
1039                 }\r
1040 \r
1041 \r
1042 \r
1043                 [TestFixture]\r
1044                 public class MultiLevelUnOrderedOfOrdered\r
1045                 {\r
1046                         private ISequenced<int> dit, dat, dut, dot;\r
1047 \r
1048                         private ICollection<ISequenced<int>> Dit, Dat, Dut, Dot;\r
1049 \r
1050 \r
1051                         [SetUp]\r
1052                         public void Init()\r
1053                         {\r
1054                                 dit = new LinkedList<int>();\r
1055                                 dat = new LinkedList<int>();\r
1056                                 dut = new LinkedList<int>();\r
1057                                 dot = new LinkedList<int>();\r
1058                                 dit.Add(2);dit.Add(1);\r
1059                                 dat.Add(1);dat.Add(2);\r
1060                                 dut.Add(3);\r
1061                                 dot.Add(2);dot.Add(1);\r
1062                                 Dit = new HashSet<ISequenced<int>>();\r
1063                                 Dat = new HashSet<ISequenced<int>>();\r
1064                                 Dut = new HashSet<ISequenced<int>>();\r
1065                                 Dot = new HashSet<ISequenced<int>>();\r
1066                         }\r
1067 \r
1068 \r
1069                         [Test]\r
1070                         public void Check()\r
1071                         {\r
1072                                 Assert.IsFalse(dit.SequencedEquals(dat));\r
1073                                 Assert.IsTrue(dit.SequencedEquals(dot));\r
1074                                 Assert.IsFalse(dit.SequencedEquals(dut));\r
1075                         }\r
1076 \r
1077 \r
1078                         [Test]\r
1079                         public void Multi()\r
1080                         {\r
1081                                 Dit.Add(dit);Dit.Add(dut);//Dit.Add(dit);\r
1082                                 Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
1083                                 Dut.Add(dot);Dut.Add(dut);//Dut.Add(dit);\r
1084                                 Dot.Add(dit);Dot.Add(dit);Dot.Add(dut);\r
1085                                 Assert.IsTrue(Dit.UnsequencedEquals(Dit));\r
1086                                 Assert.IsTrue(Dit.UnsequencedEquals(Dut));\r
1087                                 Assert.IsFalse(Dit.UnsequencedEquals(Dat));\r
1088                                 Assert.IsTrue(Dit.UnsequencedEquals(Dot));\r
1089                         }\r
1090 \r
1091 \r
1092                         [TearDown]\r
1093                         public void Dispose()\r
1094                         {\r
1095                                 dit = dat = dut = dot = null;\r
1096                                 Dit = Dat = Dut = Dot = null;\r
1097                         }\r
1098                 }\r
1099         }\r
1100 }\r