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