mcs/class/Mono.C5/Test/hashing/HashTableTests.cs

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