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