mcs/class/Mono.C5/Test/linkedlists/LinkedListTest.cs

   1 /*\r
   2  Copyright (c) 2003-2004 Niels Kokholm <kokholm@itu.dk> and Peter Sestoft <sestoft@dina.kvl.dk>\r
   3  Permission is hereby granted, free of charge, to any person obtaining a copy\r
   4  of this software and associated documentation files (the "Software"), to deal\r
   5  in the Software without restriction, including without limitation the rights\r
   6  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r
   7  copies of the Software, and to permit persons to whom the Software is\r
   8  furnished to do so, subject to the following conditions:\r
   9  \r
  10  The above copyright notice and this permission notice shall be included in\r
  11  all copies or substantial portions of the Software.\r
  12  \r
  13  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  14  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
  15  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r
  16  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r
  17  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
  18  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
  19  SOFTWARE.\r
  20 */\r
  21 \r
  22 using System;\r
  23 using C5;\r
  24 using NUnit.Framework;\r
  25 using MSG = System.Collections.Generic;\r
  26 \r
  27 \r
  28 namespace nunit.linkedlists.plain\r
  29 {\r
  30         namespace Enumerable\r
  31         {\r
  32                 [TestFixture]\r
  33                 public class Multiops\r
  34                 {\r
  35                         private LinkedList<int> list;\r
  36 \r
  37                         private Filter<int> always, never, even;\r
  38 \r
  39 \r
  40                         [SetUp]\r
  41                         public void Init()\r
  42                         {\r
  43                                 list = new LinkedList<int>();\r
  44                                 always = delegate{return true;};\r
  45                                 never = delegate{return false;};\r
  46                                 even = delegate(int i){return i%2==0;};\r
  47                         }\r
  48 \r
  49 \r
  50                         [Test]\r
  51                         public void All()\r
  52                         {\r
  53                                 Assert.IsTrue(list.All(always));\r
  54                                 Assert.IsTrue(list.All(never));\r
  55                                 Assert.IsTrue(list.All(even));\r
  56                                 list.Add(8);\r
  57                                 Assert.IsTrue(list.All(always));\r
  58                                 Assert.IsFalse(list.All(never));\r
  59                                 Assert.IsTrue(list.All(even));\r
  60                                 list.Add(5);\r
  61                                 Assert.IsTrue(list.All(always));\r
  62                                 Assert.IsFalse(list.All(never));\r
  63                                 Assert.IsFalse(list.All(even));\r
  64                         }\r
  65 \r
  66 \r
  67                         [Test]\r
  68                         public void Exists()\r
  69                         {\r
  70                                 Assert.IsFalse(list.Exists(always));\r
  71                                 Assert.IsFalse(list.Exists(never));\r
  72                                 Assert.IsFalse(list.Exists(even));\r
  73                                 list.Add(5);\r
  74                                 Assert.IsTrue(list.Exists(always));\r
  75                                 Assert.IsFalse(list.Exists(never));\r
  76                                 Assert.IsFalse(list.Exists(even));\r
  77                                 list.Add(8);\r
  78                                 Assert.IsTrue(list.Exists(always));\r
  79                                 Assert.IsFalse(list.Exists(never));\r
  80                                 Assert.IsTrue(list.Exists(even));\r
  81                         }\r
  82 \r
  83 \r
  84                         [Test]\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(5875, 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 LinkedList<int> list;\r
 109 \r
 110 \r
 111                         [SetUp]\r
 112                         public void Init() { list = new LinkedList<int>(); }\r
 113 \r
 114 \r
 115                         [Test]\r
 116                         public void Empty()\r
 117                         {\r
 118                                 MSG.IEnumerator<int> e = list.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                                 list.Add(5);\r
 128                                 list.Add(8);\r
 129                                 list.Add(5);\r
 130                                 list.Add(5);\r
 131                                 list.Add(10);\r
 132                                 list.Add(1);\r
 133 \r
 134                                 MSG.IEnumerator<int> e = list.GetEnumerator();\r
 135 \r
 136                                 Assert.IsTrue(e.MoveNext());\r
 137                                 Assert.AreEqual(5, e.Current);\r
 138                                 Assert.IsTrue(e.MoveNext());\r
 139                                 Assert.AreEqual(8, e.Current);\r
 140                                 Assert.IsTrue(e.MoveNext());\r
 141                                 Assert.AreEqual(5, e.Current);\r
 142                                 Assert.IsTrue(e.MoveNext());\r
 143                                 Assert.AreEqual(5, e.Current);\r
 144                                 Assert.IsTrue(e.MoveNext());\r
 145                                 Assert.AreEqual(10, e.Current);\r
 146                                 Assert.IsTrue(e.MoveNext());\r
 147                                 Assert.AreEqual(1, e.Current);\r
 148                                 Assert.IsFalse(e.MoveNext());\r
 149                         }\r
 150 \r
 151 \r
 152                         [Test]\r
 153                         public void DoDispose()\r
 154                         {\r
 155                                 list.Add(5);\r
 156                                 list.Add(8);\r
 157                                 list.Add(5);\r
 158 \r
 159                                 MSG.IEnumerator<int> e = list.GetEnumerator();\r
 160 \r
 161                                 e.MoveNext();\r
 162                                 e.MoveNext();\r
 163                                 e.Dispose();\r
 164                         }\r
 165 \r
 166 \r
 167                         [Test]\r
 168                         [ExpectedException(typeof(InvalidOperationException))]\r
 169                         public void MoveNextAfterUpdate()\r
 170                         {\r
 171                                 list.Add(5);\r
 172                                 list.Add(8);\r
 173                                 list.Add(5);\r
 174 \r
 175                                 MSG.IEnumerator<int> e = list.GetEnumerator();\r
 176 \r
 177                                 e.MoveNext();\r
 178                                 list.Add(99);\r
 179                                 e.MoveNext();\r
 180                         }\r
 181 \r
 182 \r
 183                         [TearDown]\r
 184                         public void Dispose() { list = null; }\r
 185                 }\r
 186         }\r
 187 \r
 188 \r
 189 \r
 190 \r
 191         namespace CollectionOrExtensible\r
 192         {\r
 193                 [TestFixture]\r
 194                 public class CollectionOrSink\r
 195                 {\r
 196                         private LinkedList<int> list;\r
 197 \r
 198 \r
 199                         [SetUp]\r
 200                         public void Init() { list = new LinkedList<int>(); }\r
 201 \r
 202 \r
 203                         [Test]\r
 204                         public void CountEtAl()\r
 205                         {\r
 206                                 Assert.AreEqual(0, list.Count);\r
 207                                 Assert.IsTrue(list.IsEmpty);\r
 208                                 Assert.IsTrue(list.AllowsDuplicates);\r
 209                                 list.Add(5);\r
 210                                 Assert.AreEqual(1, list.Count);\r
 211                                 Assert.IsFalse(list.IsEmpty);\r
 212                                 list.Add(5);\r
 213                                 Assert.AreEqual(2, list.Count);\r
 214                                 Assert.IsFalse(list.IsEmpty);\r
 215                                 list.Add(8);\r
 216                                 Assert.AreEqual(3, list.Count);\r
 217                         }\r
 218 \r
 219 \r
 220                         [Test]\r
 221                         public void AddAll()\r
 222                         {\r
 223                                 list.Add(3);list.Add(4);list.Add(5);\r
 224 \r
 225                                 LinkedList<int> list2 = new LinkedList<int>();\r
 226 \r
 227                                 list2.AddAll(list);\r
 228                                 Assert.IsTrue(IC.eq(list2, 3, 4, 5));\r
 229                                 list.AddAll(list2);\r
 230                                 Assert.IsTrue(IC.eq(list2, 3, 4, 5));\r
 231                                 Assert.IsTrue(IC.eq(list, 3, 4, 5, 3, 4, 5));\r
 232                         }\r
 233 \r
 234 \r
 235                         [TearDown]\r
 236                         public void Dispose() { list = null; }\r
 237                 }\r
 238 \r
 239 \r
 240 \r
 241                 [TestFixture]\r
 242                 public class ArrayTest\r
 243                 {\r
 244                         private LinkedList<int> list;\r
 245 \r
 246                         int[] a;\r
 247 \r
 248 \r
 249                         [SetUp]\r
 250                         public void Init()\r
 251                         {\r
 252                                 list = new LinkedList<int>();\r
 253                                 a = new int[10];\r
 254                                 for (int i = 0; i < 10; i++)\r
 255                                         a[i] = 1000 + i;\r
 256                         }\r
 257 \r
 258 \r
 259                         [TearDown]\r
 260                         public void Dispose() { list = null; }\r
 261 \r
 262 \r
 263                         private string aeq(int[] a, params int[] b)\r
 264                         {\r
 265                                 if (a.Length != b.Length)\r
 266                                         return "Lengths differ: " + a.Length + " != " + b.Length;\r
 267 \r
 268                                 for (int i = 0; i < a.Length; i++)\r
 269                                         if (a[i] != b[i])\r
 270                                                 return String.Format("{0}'th elements differ: {1} != {2}", i, a[i], b[i]);\r
 271 \r
 272                                 return "Alles klar";\r
 273                         }\r
 274 \r
 275 \r
 276                         [Test]\r
 277                         public void ToArray()\r
 278                         {\r
 279                                 Assert.AreEqual("Alles klar", aeq(list.ToArray()));\r
 280                                 list.Add(7);\r
 281                                 list.Add(7);\r
 282                                 Assert.AreEqual("Alles klar", aeq(list.ToArray(), 7, 7));\r
 283                         }\r
 284 \r
 285 \r
 286                         [Test]\r
 287                         public void CopyTo()\r
 288                         {\r
 289                                 list.CopyTo(a, 1);\r
 290                                 Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009));\r
 291                                 list.Add(6);\r
 292                                 list.CopyTo(a, 2);\r
 293                                 Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 6, 1003, 1004, 1005, 1006, 1007, 1008, 1009));\r
 294                                 list.Add(4);\r
 295                                 list.Add(4);\r
 296                                 list.Add(9);\r
 297                                 list.CopyTo(a, 4);\r
 298                                 Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 6, 1003, 6, 4, 4, 9, 1008, 1009));\r
 299                                 list.Clear();\r
 300                                 list.Add(7);\r
 301                                 list.CopyTo(a, 9);\r
 302                                 Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 6, 1003, 6, 4, 4, 9, 1008, 7));\r
 303                         }\r
 304 \r
 305 \r
 306                         [Test]\r
 307                         [ExpectedException(typeof(ArgumentException))]\r
 308                         public void CopyToBad()\r
 309                         {\r
 310                                 list.Add(3);\r
 311                                 list.CopyTo(a, 10);\r
 312                         }\r
 313 \r
 314 \r
 315                         [Test]\r
 316                         [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
 317                         public void CopyToBad2()\r
 318                         {\r
 319                                 list.CopyTo(a, -1);\r
 320                         }\r
 321 \r
 322 \r
 323                         [Test]\r
 324                         [ExpectedException(typeof(ArgumentException))]\r
 325                         public void CopyToTooFar()\r
 326                         {\r
 327                                 list.Add(3);\r
 328                                 list.Add(3);\r
 329                                 list.CopyTo(a, 9);\r
 330                         }\r
 331                 }\r
 332 \r
 333 \r
 334 \r
 335                 [TestFixture]\r
 336                 public class Sync\r
 337                 {\r
 338                         private LinkedList<int> list;\r
 339 \r
 340 \r
 341                         [SetUp]\r
 342                         public void Init()\r
 343                         {\r
 344                                 list = new LinkedList<int>();\r
 345                         }\r
 346 \r
 347 \r
 348                         [TearDown]\r
 349                         public void Dispose() { list = null; }\r
 350 \r
 351 \r
 352                         [Test]\r
 353                         public void Get()\r
 354                         {\r
 355                                 Assert.IsNotNull(list.SyncRoot);\r
 356                         }\r
 357                 }\r
 358         }\r
 359 \r
 360 \r
 361 \r
 362 \r
 363         namespace EditableCollection\r
 364         {\r
 365                 [TestFixture]\r
 366                 public class Searching\r
 367                 {\r
 368                         private LinkedList<int> list;\r
 369 \r
 370 \r
 371                         [SetUp]\r
 372                         public void Init() { list = new LinkedList<int>(); }\r
 373 \r
 374 \r
 375                         [Test]\r
 376                         public void Contains()\r
 377                         {\r
 378                                 Assert.IsFalse(list.Contains(5));\r
 379                                 list.Add(5);\r
 380                                 Assert.IsTrue(list.Contains(5));\r
 381                                 Assert.IsFalse(list.Contains(7));\r
 382                                 list.Add(8);\r
 383                                 list.Add(10);\r
 384                                 Assert.IsTrue(list.Contains(5));\r
 385                                 Assert.IsFalse(list.Contains(7));\r
 386                                 Assert.IsTrue(list.Contains(8));\r
 387                                 Assert.IsTrue(list.Contains(10));\r
 388                                 list.Remove(8);\r
 389                                 Assert.IsTrue(list.Contains(5));\r
 390                                 Assert.IsFalse(list.Contains(7));\r
 391                                 Assert.IsFalse(list.Contains(8));\r
 392                                 Assert.IsTrue(list.Contains(10));\r
 393                         }\r
 394 \r
 395 \r
 396                         [Test]\r
 397                         public void ContainsCount()\r
 398                         {\r
 399                                 Assert.AreEqual(0, list.ContainsCount(5));\r
 400                                 list.Add(5);\r
 401                                 Assert.AreEqual(1, list.ContainsCount(5));\r
 402                                 Assert.AreEqual(0, list.ContainsCount(7));\r
 403                                 list.Add(8);\r
 404                                 Assert.AreEqual(1, list.ContainsCount(5));\r
 405                                 Assert.AreEqual(0, list.ContainsCount(7));\r
 406                                 Assert.AreEqual(1, list.ContainsCount(8));\r
 407                                 list.Add(5);\r
 408                                 Assert.AreEqual(2, list.ContainsCount(5));\r
 409                                 Assert.AreEqual(0, list.ContainsCount(7));\r
 410                                 Assert.AreEqual(1, list.ContainsCount(8));\r
 411                         }\r
 412 \r
 413 \r
 414                         [Test]\r
 415                         public void RemoveAllCopies()\r
 416                         {\r
 417                                 list.Add(5);list.Add(7);list.Add(5);\r
 418                                 Assert.AreEqual(2, list.ContainsCount(5));\r
 419                                 Assert.AreEqual(1, list.ContainsCount(7));\r
 420                                 list.RemoveAllCopies(5);\r
 421                                 Assert.AreEqual(0, list.ContainsCount(5));\r
 422                                 Assert.AreEqual(1, list.ContainsCount(7));\r
 423                                 list.Add(5);list.Add(8);list.Add(5);\r
 424                                 list.RemoveAllCopies(8);\r
 425                                 Assert.IsTrue(IC.eq(list, 7, 5, 5));\r
 426                         }\r
 427 \r
 428 \r
 429                         [Test]\r
 430                         public void FindAll()\r
 431                         {\r
 432                                 Filter<int> f = delegate(int i){return i%2==0;};\r
 433 \r
 434                                 Assert.IsTrue(list.FindAll(f).IsEmpty);\r
 435                                 list.Add(5);list.Add(8);list.Add(5);list.Add(10);list.Add(8);\r
 436                                 Assert.IsTrue(((LinkedList<int>)list.FindAll(f)).Check());\r
 437                                 Assert.IsTrue(IC.eq(list.FindAll(f), 8, 10, 8));\r
 438                         }\r
 439 \r
 440 \r
 441                         [Test]\r
 442                         public void ContainsAll()\r
 443                         {\r
 444                                 LinkedList<int> list2 = new LinkedList<int>();\r
 445 \r
 446                                 Assert.IsTrue(list.ContainsAll(list2));\r
 447                                 list2.Add(4);\r
 448                                 Assert.IsFalse(list.ContainsAll(list2));\r
 449                                 list.Add(4);\r
 450                                 Assert.IsTrue(list.ContainsAll(list2));\r
 451                                 list.Add(5);\r
 452                                 Assert.IsTrue(list.ContainsAll(list2));\r
 453                                 list2.Add(4);\r
 454                                 Assert.IsFalse(list.ContainsAll(list2));\r
 455                                 list.Add(4);\r
 456                                 Assert.IsTrue(list.ContainsAll(list2));\r
 457                         }\r
 458 \r
 459 \r
 460                         [Test]\r
 461                         public void RetainAll()\r
 462                         {\r
 463                                 LinkedList<int> list2 = new LinkedList<int>();\r
 464 \r
 465                                 list.Add(4);list.Add(4);list.Add(5);list.Add(4);list.Add(6);\r
 466                                 list2.Add(5);list2.Add(4);list2.Add(7);list2.Add(7);list2.Add(4);\r
 467                                 list.RetainAll(list2);\r
 468                                 Assert.IsTrue(list.Check());\r
 469                                 Assert.IsTrue(IC.eq(list, 4, 4, 5));\r
 470                                 list.Add(5);list.Add(4);list.Add(6);\r
 471                                 list2.Clear();\r
 472                                 list2.Add(5);list2.Add(5);list2.Add(6);\r
 473                                 list.RetainAll(list2);\r
 474                                 Assert.IsTrue(list.Check());\r
 475                                 Assert.IsTrue(IC.eq(list, 5, 5, 6));\r
 476                                 list2.Clear();\r
 477                                 list2.Add(7);list2.Add(8);list2.Add(9);\r
 478                                 list.RetainAll(list2);\r
 479                                 Assert.IsTrue(list.Check());\r
 480                                 Assert.IsTrue(IC.eq(list));\r
 481                         }\r
 482 \r
 483 \r
 484                         [Test]\r
 485                         public void RemoveAll()\r
 486                         {\r
 487                                 LinkedList<int> list2 = new LinkedList<int>();\r
 488 \r
 489                                 list.Add(4);list.Add(4);list.Add(5);list.Add(4);list.Add(6);\r
 490                                 list2.Add(5);list2.Add(4);list2.Add(7);list2.Add(7);list2.Add(4);\r
 491                                 list.RemoveAll(list2);\r
 492                                 Assert.IsTrue(list.Check());\r
 493                                 Assert.IsTrue(IC.eq(list, 4, 6));\r
 494                                 list.Add(5);list.Add(4);list.Add(6);\r
 495                                 list2.Clear();\r
 496                                 list2.Add(6);list2.Add(5);list2.Add(5);list2.Add(6);\r
 497                                 list.RemoveAll(list2);\r
 498                                 Assert.IsTrue(list.Check());\r
 499                                 Assert.IsTrue(IC.eq(list, 4, 4));\r
 500                                 list2.Clear();\r
 501                                 list2.Add(7);list2.Add(8);list2.Add(9);\r
 502                                 list.RemoveAll(list2);\r
 503                                 Assert.IsTrue(list.Check());\r
 504                                 Assert.IsTrue(IC.eq(list, 4, 4));\r
 505                         }\r
 506 \r
 507 \r
 508                         [Test]\r
 509                         public void Remove()\r
 510                         {\r
 511                                 list.Add(4);list.Add(4);list.Add(5);list.Add(4);list.Add(6);\r
 512                                 Assert.IsFalse(list.Remove(2));\r
 513                                 Assert.IsTrue(list.Check());\r
 514                                 Assert.IsTrue(list.Remove(4));\r
 515                                 Assert.IsTrue(list.Check());\r
 516                                 Assert.IsTrue(IC.eq(list, 4, 5, 4, 6));\r
 517                                 Assert.AreEqual(6, list.RemoveLast());\r
 518                                 Assert.IsTrue(list.Check());\r
 519                                 Assert.IsTrue(IC.eq(list, 4, 5, 4));\r
 520                                 list.Add(7);\r
 521                                 Assert.AreEqual(4, list.RemoveFirst());\r
 522                                 Assert.IsTrue(list.Check());\r
 523                                 Assert.IsTrue(IC.eq(list, 5, 4, 7));\r
 524                         }\r
 525 \r
 526 \r
 527                         [Test]\r
 528                         public void Clear()\r
 529                         {\r
 530                                 list.Add(7);list.Add(7);\r
 531                                 list.Clear();\r
 532                                 Assert.IsTrue(list.IsEmpty);\r
 533                         }\r
 534 \r
 535 \r
 536                         [TearDown]\r
 537                         public void Dispose() { list = null; }\r
 538                 }\r
 539         }\r
 540 \r
 541 \r
 542 \r
 543 \r
 544         namespace IIndexed\r
 545         {\r
 546                 [TestFixture]\r
 547                 public class Searching\r
 548                 {\r
 549                         private IIndexed<int> dit;\r
 550 \r
 551 \r
 552                         [SetUp]\r
 553                         public void Init()\r
 554                         {\r
 555                                 dit = new LinkedList<int>();\r
 556                         }\r
 557 \r
 558 \r
 559                         [Test]\r
 560                         public void IndexOf()\r
 561                         {\r
 562                                 Assert.AreEqual(-1, dit.IndexOf(6));\r
 563                                 dit.Add(7);\r
 564                                 Assert.AreEqual(-1, dit.IndexOf(6));\r
 565                                 Assert.AreEqual(-1, dit.LastIndexOf(6));\r
 566                                 Assert.AreEqual(0, dit.IndexOf(7));\r
 567                                 dit.Add(5);dit.Add(7);dit.Add(8);dit.Add(7);\r
 568                                 Assert.AreEqual(-1, dit.IndexOf(6));\r
 569                                 Assert.AreEqual(0, dit.IndexOf(7));\r
 570                                 Assert.AreEqual(4, dit.LastIndexOf(7));\r
 571                                 Assert.AreEqual(3, dit.IndexOf(8));\r
 572                                 Assert.AreEqual(1, dit.LastIndexOf(5));\r
 573                         }\r
 574 \r
 575 \r
 576                         [TearDown]\r
 577                         public void Dispose()\r
 578                         {\r
 579                                 dit = null;\r
 580                         }\r
 581                 }\r
 582 \r
 583 \r
 584 \r
 585                 [TestFixture]\r
 586                 public class Removing\r
 587                 {\r
 588                         private IIndexed<int> dit;\r
 589 \r
 590 \r
 591                         [SetUp]\r
 592                         public void Init()\r
 593                         {\r
 594                                 dit = new LinkedList<int>();\r
 595                         }\r
 596 \r
 597 \r
 598                         [Test]\r
 599                         public void RemoveAt()\r
 600                         {\r
 601                                 dit.Add(5);dit.Add(7);dit.Add(9);dit.Add(1);dit.Add(2);\r
 602                                 Assert.AreEqual(7, dit.RemoveAt(1));\r
 603                                 Assert.IsTrue(((LinkedList<int>)dit).Check());\r
 604                                 Assert.IsTrue(IC.eq(dit, 5, 9, 1, 2));\r
 605                                 Assert.AreEqual(5, dit.RemoveAt(0));\r
 606                                 Assert.IsTrue(((LinkedList<int>)dit).Check());\r
 607                                 Assert.IsTrue(IC.eq(dit, 9, 1, 2));\r
 608                                 Assert.AreEqual(2, dit.RemoveAt(2));\r
 609                                 Assert.IsTrue(((LinkedList<int>)dit).Check());\r
 610                                 Assert.IsTrue(IC.eq(dit, 9, 1));\r
 611                         }\r
 612 \r
 613 \r
 614                         [Test]\r
 615                         [ExpectedException(typeof(IndexOutOfRangeException))]\r
 616                         public void RemoveAtBad0()\r
 617                         {\r
 618                                 dit.RemoveAt(0);\r
 619                         }\r
 620 \r
 621 \r
 622                         [Test]\r
 623                         [ExpectedException(typeof(IndexOutOfRangeException))]\r
 624                         public void RemoveAtBadM1()\r
 625                         {\r
 626                                 dit.RemoveAt(-1);\r
 627                         }\r
 628 \r
 629 \r
 630                         [Test]\r
 631                         [ExpectedException(typeof(IndexOutOfRangeException))]\r
 632                         public void RemoveAtBad1()\r
 633                         {\r
 634                                 dit.Add(8);\r
 635                                 dit.RemoveAt(1);\r
 636                         }\r
 637 \r
 638 \r
 639                         [Test]\r
 640                         public void RemoveInterval()\r
 641                         {\r
 642                                 dit.RemoveInterval(0, 0);\r
 643                                 dit.Add(10);dit.Add(20);dit.Add(30);dit.Add(40);dit.Add(50);dit.Add(60);\r
 644                                 dit.RemoveInterval(3, 0);\r
 645                                 Assert.IsTrue(((LinkedList<int>)dit).Check());\r
 646                                 Assert.IsTrue(IC.eq(dit, 10, 20, 30, 40, 50, 60));\r
 647                                 dit.RemoveInterval(3, 1);\r
 648                                 Assert.IsTrue(((LinkedList<int>)dit).Check());\r
 649                                 Assert.IsTrue(IC.eq(dit, 10, 20, 30, 50, 60));\r
 650                                 dit.RemoveInterval(1, 3);\r
 651                                 Assert.IsTrue(((LinkedList<int>)dit).Check());\r
 652                                 Assert.IsTrue(IC.eq(dit, 10, 60));\r
 653                                 dit.RemoveInterval(0, 2);\r
 654                                 Assert.IsTrue(((LinkedList<int>)dit).Check());\r
 655                                 Assert.IsTrue(IC.eq(dit));\r
 656                                 dit.Add(10);dit.Add(20);dit.Add(30);dit.Add(40);dit.Add(50);dit.Add(60);\r
 657                                 dit.RemoveInterval(0, 2);\r
 658                                 Assert.IsTrue(((LinkedList<int>)dit).Check());\r
 659                                 Assert.IsTrue(IC.eq(dit, 30, 40, 50, 60));\r
 660                                 dit.RemoveInterval(2, 2);\r
 661                                 Assert.IsTrue(((LinkedList<int>)dit).Check());\r
 662                                 Assert.IsTrue(IC.eq(dit, 30, 40));\r
 663                         }\r
 664 \r
 665 \r
 666                         [TearDown]\r
 667                         public void Dispose()\r
 668                         {\r
 669                                 dit = null;\r
 670                         }\r
 671                 }\r
 672         }\r
 673 \r
 674 \r
 675 \r
 676 \r
 677         namespace IList\r
 678         {\r
 679                 [TestFixture]\r
 680                 public class Searching\r
 681                 {\r
 682                         private IList<int> lst;\r
 683 \r
 684 \r
 685                         [SetUp]\r
 686                         public void Init() { lst = new LinkedList<int>(); }\r
 687 \r
 688 \r
 689                         [TearDown]\r
 690                         public void Dispose() { lst = null; }\r
 691 \r
 692 \r
 693                         [Test]\r
 694                         [ExpectedException(typeof(InvalidOperationException), "List is empty")]\r
 695                         public void FirstBad()\r
 696                         {\r
 697                                 int f = lst.First;\r
 698                         }\r
 699 \r
 700 \r
 701                         [Test]\r
 702                         [ExpectedException(typeof(InvalidOperationException), "List is empty")]\r
 703                         public void LastBad()\r
 704                         {\r
 705                                 int f = lst.Last;\r
 706                         }\r
 707 \r
 708 \r
 709                         [Test]\r
 710                         public void FirstLast()\r
 711                         {\r
 712                                 lst.Add(19);\r
 713                                 Assert.AreEqual(19, lst.First);\r
 714                                 Assert.AreEqual(19, lst.Last);\r
 715                                 lst.Add(34);lst.InsertFirst(12);\r
 716                                 Assert.AreEqual(12, lst.First);\r
 717                                 Assert.AreEqual(34, lst.Last);\r
 718                         }\r
 719 \r
 720 \r
 721                         [Test]\r
 722                         public void This()\r
 723                         {\r
 724                                 lst.Add(34);\r
 725                                 Assert.AreEqual(34, lst[0]);\r
 726                                 lst[0] = 56;\r
 727                                 Assert.AreEqual(56, lst.First);\r
 728                                 lst.Add(7);lst.Add(7);lst.Add(7);lst.Add(7);\r
 729                                 lst[0] = 45;lst[2] = 78;lst[4] = 101;\r
 730                                 Assert.IsTrue(IC.eq(lst, 45, 7, 78, 7, 101));\r
 731                         }\r
 732 \r
 733 \r
 734                         [Test]\r
 735                         [ExpectedException(typeof(IndexOutOfRangeException))]\r
 736                         public void ThisBadEmptyGet()\r
 737                         {\r
 738                                 int f = lst[0];\r
 739                         }\r
 740 \r
 741 \r
 742                         [Test]\r
 743                         [ExpectedException(typeof(IndexOutOfRangeException))]\r
 744                         public void ThisBadLowGet()\r
 745                         {\r
 746                                 lst.Add(7);\r
 747 \r
 748                                 int f = lst[-1];\r
 749                         }\r
 750 \r
 751 \r
 752                         [Test]\r
 753                         [ExpectedException(typeof(IndexOutOfRangeException))]\r
 754                         public void ThisBadHiGet()\r
 755                         {\r
 756                                 lst.Add(6);\r
 757 \r
 758                                 int f = lst[1];\r
 759                         }\r
 760 \r
 761 \r
 762                         [Test]\r
 763                         [ExpectedException(typeof(IndexOutOfRangeException))]\r
 764                         public void ThisBadEmptySet()\r
 765                         {\r
 766                                 lst[0] = 4;\r
 767                         }\r
 768 \r
 769 \r
 770                         [Test]\r
 771                         [ExpectedException(typeof(IndexOutOfRangeException))]\r
 772                         public void ThisBadLowSet()\r
 773                         {\r
 774                                 lst.Add(7);\r
 775                                 lst[-1] = 9;\r
 776                         }\r
 777 \r
 778 \r
 779                         [Test]\r
 780                         [ExpectedException(typeof(IndexOutOfRangeException))]\r
 781                         public void ThisBadHiSet()\r
 782                         {\r
 783                                 lst.Add(6);\r
 784                                 lst[1] = 11;\r
 785                         }\r
 786                 }\r
 787 \r
 788 \r
 789                 [TestFixture]\r
 790                 public class Combined\r
 791                 {\r
 792                         private IList<KeyValuePair<int,int>> lst;\r
 793 \r
 794 \r
 795                         [SetUp]\r
 796                         public void Init()\r
 797                         {\r
 798                                 lst = new LinkedList<KeyValuePair<int,int>>();\r
 799                                 for (int i = 0; i < 10; i++)\r
 800                                         lst.Add(new KeyValuePair<int,int>(i, i + 30));\r
 801                         }\r
 802 \r
 803 \r
 804                         [TearDown]\r
 805                         public void Dispose() { lst = null; }\r
 806 \r
 807 \r
 808                         [Test]\r
 809                         public void Find()\r
 810                         {\r
 811                                 KeyValuePair<int,int> p = new KeyValuePair<int,int>(3, 78);\r
 812 \r
 813                                 Assert.IsTrue(lst.Find(ref p));\r
 814                                 Assert.AreEqual(3, p.key);\r
 815                                 Assert.AreEqual(33, p.value);\r
 816                                 p = new KeyValuePair<int,int>(13, 78);\r
 817                                 Assert.IsFalse(lst.Find(ref p));\r
 818                         }\r
 819 \r
 820 \r
 821                         [Test]\r
 822                         public void FindOrAdd()\r
 823                         {\r
 824                                 KeyValuePair<int,int> p = new KeyValuePair<int,int>(3, 78);\r
 825 \r
 826                                 Assert.IsTrue(lst.FindOrAdd(ref p));\r
 827                                 Assert.AreEqual(3, p.key);\r
 828                                 Assert.AreEqual(33, p.value);\r
 829                                 p = new KeyValuePair<int,int>(13, 79);\r
 830                                 Assert.IsFalse(lst.FindOrAdd(ref p));\r
 831                                 Assert.AreEqual(13, lst[10].key);\r
 832                                 Assert.AreEqual(79, lst[10].value);\r
 833                         }\r
 834 \r
 835 \r
 836                         [Test]\r
 837                         public void Update()\r
 838                         {\r
 839                                 KeyValuePair<int,int> p = new KeyValuePair<int,int>(3, 78);\r
 840 \r
 841                                 Assert.IsTrue(lst.Update(p));\r
 842                                 Assert.AreEqual(3, lst[3].key);\r
 843                                 Assert.AreEqual(78, lst[3].value);\r
 844                                 p = new KeyValuePair<int,int>(13, 78);\r
 845                                 Assert.IsFalse(lst.Update(p));\r
 846                         }\r
 847 \r
 848 \r
 849                         [Test]\r
 850                         public void UpdateOrAdd()\r
 851                         {\r
 852                                 KeyValuePair<int,int> p = new KeyValuePair<int,int>(3, 78);\r
 853 \r
 854                                 Assert.IsTrue(lst.UpdateOrAdd(p));\r
 855                                 Assert.AreEqual(3, lst[3].key);\r
 856                                 Assert.AreEqual(78, lst[3].value);\r
 857                                 p = new KeyValuePair<int,int>(13, 79);\r
 858                                 Assert.IsFalse(lst.UpdateOrAdd(p));\r
 859                                 Assert.AreEqual(13, lst[10].key);\r
 860                                 Assert.AreEqual(79, lst[10].value);\r
 861                         }\r
 862 \r
 863 \r
 864                         [Test]\r
 865                         public void RemoveWithReturn()\r
 866                         {\r
 867                                 KeyValuePair<int,int> p = new KeyValuePair<int,int>(3, 78);\r
 868 \r
 869                                 Assert.IsTrue(lst.RemoveWithReturn(ref p));\r
 870                                 Assert.AreEqual(3, p.key);\r
 871                                 Assert.AreEqual(33, p.value);\r
 872                                 Assert.AreEqual(4, lst[3].key);\r
 873                                 Assert.AreEqual(34, lst[3].value);\r
 874                                 p = new KeyValuePair<int,int>(13, 78);\r
 875                                 Assert.IsFalse(lst.RemoveWithReturn(ref p));\r
 876                         }\r
 877                 }\r
 878 \r
 879 \r
 880                 [TestFixture]\r
 881                 public class Inserting\r
 882                 {\r
 883                         private IList<int> lst;\r
 884 \r
 885 \r
 886                         [SetUp]\r
 887                         public void Init() { lst = new LinkedList<int>(); }\r
 888 \r
 889 \r
 890                         [TearDown]\r
 891                         public void Dispose() { lst = null; }\r
 892 \r
 893 \r
 894                         [Test]\r
 895                         public void Insert()\r
 896                         {\r
 897                                 lst.Insert(0, 5);\r
 898                                 Assert.IsTrue(IC.eq(lst, 5));\r
 899                                 lst.Insert(0, 7);\r
 900                                 Assert.IsTrue(IC.eq(lst, 7, 5));\r
 901                                 lst.Insert(1, 4);\r
 902                                 Assert.IsTrue(IC.eq(lst, 7, 4, 5));\r
 903                                 lst.Insert(3, 2);\r
 904                                 Assert.IsTrue(IC.eq(lst, 7, 4, 5, 2));\r
 905                         }\r
 906 \r
 907 \r
 908                         [Test]\r
 909                         [ExpectedException(typeof(IndexOutOfRangeException))]\r
 910                         public void BadInsertLow()\r
 911                         {\r
 912                                 lst.Add(7);\r
 913                                 lst.Insert(-1, 9);\r
 914                         }\r
 915 \r
 916 \r
 917                         [Test]\r
 918                         [ExpectedException(typeof(IndexOutOfRangeException))]\r
 919                         public void BadInsertHi()\r
 920                         {\r
 921                                 lst.Add(6);\r
 922                                 lst.Insert(2, 11);\r
 923                         }\r
 924 \r
 925 \r
 926                         [Test]\r
 927                         public void FIFO()\r
 928                         {\r
 929                                 for (int i = 0; i < 7; i++)\r
 930                                         lst.Add(2 * i);\r
 931 \r
 932                                 Assert.IsTrue(lst.FIFO);\r
 933                                 Assert.AreEqual(0, lst.Remove());\r
 934                                 Assert.AreEqual(2, lst.Remove());\r
 935                                 lst.FIFO = false;\r
 936                                 Assert.AreEqual(12, lst.Remove());\r
 937                                 Assert.AreEqual(10, lst.Remove());\r
 938                                 lst.FIFO = true;\r
 939                                 Assert.AreEqual(4, lst.Remove());\r
 940                                 Assert.AreEqual(6, lst.Remove());\r
 941                         }\r
 942 \r
 943 \r
 944                         [Test]\r
 945                         public void InsertFirstLast()\r
 946                         {\r
 947                                 lst.InsertFirst(4);\r
 948                                 lst.InsertLast(5);\r
 949                                 lst.InsertFirst(14);\r
 950                                 lst.InsertLast(15);\r
 951                                 lst.InsertFirst(24);\r
 952                                 lst.InsertLast(25);\r
 953                                 lst.InsertFirst(34);\r
 954                                 lst.InsertLast(55);\r
 955                                 Assert.IsTrue(IC.eq(lst, 34, 24, 14, 4, 5, 15, 25, 55));\r
 956                         }\r
 957 \r
 958 \r
 959                         [Test]\r
 960                         public void InsertBefore()\r
 961                         {\r
 962                                 lst.Add(2);\r
 963                                 lst.Add(3);\r
 964                                 lst.Add(2);\r
 965                                 lst.Add(5);\r
 966                                 lst.InsertBefore(7, 2);\r
 967                                 Assert.IsTrue(lst.Check());\r
 968                                 Assert.IsTrue(IC.eq(lst, 7, 2, 3, 2, 5));\r
 969                                 lst.InsertBefore(8, 3);\r
 970                                 Assert.IsTrue(lst.Check());\r
 971                                 Assert.IsTrue(IC.eq(lst, 7, 2, 8, 3, 2, 5));\r
 972                                 lst.InsertBefore(9, 5);\r
 973                                 Assert.IsTrue(lst.Check());\r
 974                                 Assert.IsTrue(IC.eq(lst, 7, 2, 8, 3, 2, 9, 5));\r
 975                         }\r
 976 \r
 977 \r
 978                         [Test]\r
 979                         [ExpectedException(typeof(ArgumentException), "Target item not found")]\r
 980                         public void BadInsertBefore()\r
 981                         {\r
 982                                 lst.Add(2);\r
 983                                 lst.Add(3);\r
 984                                 lst.Add(2);\r
 985                                 lst.Add(5);\r
 986                                 lst.InsertBefore(7, 4);\r
 987                         }\r
 988 \r
 989 \r
 990                         [Test]\r
 991                         public void InsertAfter()\r
 992                         {\r
 993                                 lst.Add(1);\r
 994                                 lst.Add(2);\r
 995                                 lst.Add(3);\r
 996                                 lst.Add(2);\r
 997                                 lst.Add(5);\r
 998                                 lst.InsertAfter(7, 2);\r
 999                                 Assert.IsTrue(lst.Check());\r
1000                                 Assert.IsTrue(IC.eq(lst, 1, 2, 3, 2, 7, 5));\r
1001                                 lst.InsertAfter(8, 1);\r
1002                                 Assert.IsTrue(lst.Check());\r
1003                                 Assert.IsTrue(IC.eq(lst, 1, 8, 2, 3, 2, 7, 5));\r
1004                                 lst.InsertAfter(9, 5);\r
1005                                 Assert.IsTrue(lst.Check());\r
1006                                 Assert.IsTrue(IC.eq(lst, 1, 8, 2, 3, 2, 7, 5, 9));\r
1007                         }\r
1008 \r
1009 \r
1010                         [Test]\r
1011                         [ExpectedException(typeof(ArgumentException), "Target item not found")]\r
1012                         public void BadInsertAfter()\r
1013                         {\r
1014                                 lst.Add(2);\r
1015                                 lst.Add(3);\r
1016                                 lst.Add(2);\r
1017                                 lst.Add(5);\r
1018                                 lst.InsertAfter(7, 4);\r
1019                         }\r
1020 \r
1021 \r
1022                         [Test]\r
1023                         public void InsertAll()\r
1024                         {\r
1025                                 lst.Add(1);\r
1026                                 lst.Add(2);\r
1027                                 lst.Add(3);\r
1028                                 lst.Add(4);\r
1029 \r
1030                                 IList<int> lst2 = new LinkedList<int>();\r
1031 \r
1032                                 lst2.Add(7);lst2.Add(8);lst2.Add(9);\r
1033                                 lst.InsertAll(0, lst2);\r
1034                                 Assert.IsTrue(lst.Check());\r
1035                                 Assert.IsTrue(IC.eq(lst, 7, 8, 9, 1, 2, 3, 4));\r
1036                                 lst.InsertAll(7, lst2);\r
1037                                 Assert.IsTrue(lst.Check());\r
1038                                 Assert.IsTrue(IC.eq(lst, 7, 8, 9, 1, 2, 3, 4, 7, 8, 9));\r
1039                                 lst.InsertAll(5, lst2);\r
1040                                 Assert.IsTrue(lst.Check());\r
1041                                 Assert.IsTrue(IC.eq(lst, 7, 8, 9, 1, 2, 7, 8, 9, 3, 4, 7, 8, 9));\r
1042                         }\r
1043 \r
1044 \r
1045                         [Test]\r
1046                         public void Map()\r
1047                         {\r
1048                                 Mapper<int,string> m = delegate(int i){return "<<"+i+">>";};\r
1049                                 IList<string> r = lst.Map(m);\r
1050 \r
1051                                 Assert.IsTrue(r.Check());\r
1052                                 Assert.IsTrue(r.IsEmpty);\r
1053                                 lst.Add(1);\r
1054                                 lst.Add(2);\r
1055                                 lst.Add(3);\r
1056                                 lst.Add(4);\r
1057                                 r = lst.Map(m);\r
1058                                 Assert.IsTrue(r.Check());\r
1059                                 Assert.AreEqual(4, r.Count);\r
1060                                 for (int i = 0; i < 4; i++)\r
1061                                         Assert.AreEqual("<<" + (i + 1) + ">>", r[i]);\r
1062                         }\r
1063 \r
1064 \r
1065                         [Test]\r
1066                         public void RemoveFirstLast()\r
1067                         {\r
1068                                 lst.Add(1);\r
1069                                 lst.Add(2);\r
1070                                 lst.Add(3);\r
1071                                 lst.Add(4);\r
1072                                 Assert.AreEqual(1, lst.RemoveFirst());\r
1073                                 Assert.AreEqual(4, lst.RemoveLast());\r
1074                                 Assert.AreEqual(2, lst.RemoveFirst());\r
1075                                 Assert.AreEqual(3, lst.RemoveLast());\r
1076                                 Assert.IsTrue(lst.IsEmpty);\r
1077                         }\r
1078 \r
1079             [Test]\r
1080             [ExpectedException(typeof(InvalidOperationException))]\r
1081             public void RemoveFirstEmpty()\r
1082             {\r
1083                 lst.RemoveFirst();\r
1084             }\r
1085 \r
1086             [Test]\r
1087             [ExpectedException(typeof(InvalidOperationException))]\r
1088             public void RemoveLastEmpty()\r
1089             {\r
1090                 lst.RemoveLast();\r
1091             }\r
1092 \r
1093             [Test]\r
1094             public void Reverse()\r
1095                         {\r
1096                                 for (int i = 0; i < 10; i++)\r
1097                                         lst.Add(i);\r
1098 \r
1099                                 lst.Reverse();\r
1100                                 Assert.IsTrue(lst.Check());\r
1101                                 Assert.IsTrue(IC.eq(lst, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0));\r
1102                                 lst.Reverse(0, 3);\r
1103                                 Assert.IsTrue(lst.Check());\r
1104                                 Assert.IsTrue(IC.eq(lst, 7, 8, 9, 6, 5, 4, 3, 2, 1, 0));\r
1105                                 lst.Reverse(7, 0);\r
1106                                 Assert.IsTrue(lst.Check());\r
1107                                 Assert.IsTrue(IC.eq(lst, 7, 8, 9, 6, 5, 4, 3, 2, 1, 0));\r
1108                                 lst.Reverse(7, 3);\r
1109                                 Assert.IsTrue(lst.Check());\r
1110                                 Assert.IsTrue(IC.eq(lst, 7, 8, 9, 6, 5, 4, 3, 0, 1, 2));\r
1111                                 lst.Reverse(5, 1);\r
1112                                 Assert.IsTrue(lst.Check());\r
1113                                 Assert.IsTrue(IC.eq(lst, 7, 8, 9, 6, 5, 4, 3, 0, 1, 2));\r
1114                         }\r
1115 \r
1116 \r
1117                         [Test]\r
1118                         [ExpectedException(typeof(ArgumentException))]\r
1119                         public void BadReverse()\r
1120                         {\r
1121                                 for (int i = 0; i < 10; i++)\r
1122                                         lst.Add(i);\r
1123 \r
1124                                 lst.Reverse(8, 3);\r
1125                         }\r
1126                 }\r
1127 \r
1128 \r
1129 \r
1130                 [TestFixture]\r
1131                 public class Sorting\r
1132                 {\r
1133                         private IList<int> lst;\r
1134 \r
1135 \r
1136                         [SetUp]\r
1137                         public void Init() { lst = new LinkedList<int>(); }\r
1138 \r
1139 \r
1140                         [TearDown]\r
1141                         public void Dispose() { lst = null; }\r
1142 \r
1143 \r
1144                         [Test]\r
1145                         public void Sort()\r
1146                         {\r
1147                                 lst.Add(5);lst.Add(6);lst.Add(5);lst.Add(7);lst.Add(3);\r
1148                                 Assert.IsFalse(lst.IsSorted(new IC()));\r
1149                                 lst.Sort(new IC());\r
1150                                 Assert.IsTrue(lst.Check());\r
1151                                 Assert.IsTrue(lst.IsSorted(new IC()));\r
1152                                 Assert.IsTrue(IC.eq(lst, 3, 5, 5, 6, 7));\r
1153                         }\r
1154 \r
1155 \r
1156                         [Test]\r
1157                         public void Stability()\r
1158                         {\r
1159                                 IList<KeyValuePair<int,string>> lst2 = new LinkedList<KeyValuePair<int,string>>();\r
1160                                 IComparer<KeyValuePair<int,string>> c = new KeyValuePairComparer<int,string>(new IC());\r
1161 \r
1162                                 lst2.Add(new KeyValuePair<int,string>(5, "a"));\r
1163                                 lst2.Add(new KeyValuePair<int,string>(5, "b"));\r
1164                                 lst2.Add(new KeyValuePair<int,string>(6, "c"));\r
1165                                 lst2.Add(new KeyValuePair<int,string>(4, "d"));\r
1166                                 lst2.Add(new KeyValuePair<int,string>(3, "e"));\r
1167                                 lst2.Add(new KeyValuePair<int,string>(4, "f"));\r
1168                                 lst2.Add(new KeyValuePair<int,string>(5, "h"));\r
1169                                 Assert.IsFalse(lst2.IsSorted(c));\r
1170                                 lst2.Sort(c);\r
1171                                 Assert.IsTrue(lst2.IsSorted(c));\r
1172 \r
1173                                 KeyValuePair<int,string> p = lst2.RemoveFirst();\r
1174 \r
1175                                 Assert.AreEqual(3, p.key);\r
1176                                 Assert.AreEqual("e", p.value);\r
1177                                 p = lst2.RemoveFirst();\r
1178                                 Assert.AreEqual(4, p.key);\r
1179                                 Assert.AreEqual("d", p.value);\r
1180                                 p = lst2.RemoveFirst();\r
1181                                 Assert.AreEqual(4, p.key);\r
1182                                 Assert.AreEqual("f", p.value);\r
1183                                 p = lst2.RemoveFirst();\r
1184                                 Assert.AreEqual(5, p.key);\r
1185                                 Assert.AreEqual("a", p.value);\r
1186                                 p = lst2.RemoveFirst();\r
1187                                 Assert.AreEqual(5, p.key);\r
1188                                 Assert.AreEqual("b", p.value);\r
1189                                 p = lst2.RemoveFirst();\r
1190                                 Assert.AreEqual(5, p.key);\r
1191                                 Assert.AreEqual("h", p.value);\r
1192                                 p = lst2.RemoveFirst();\r
1193                                 Assert.AreEqual(6, p.key);\r
1194                                 Assert.AreEqual("c", p.value);\r
1195                                 Assert.IsTrue(lst2.IsEmpty);\r
1196                         }\r
1197                 }\r
1198         }\r
1199 \r
1200 \r
1201     namespace IStackQueue\r
1202     {\r
1203         [TestFixture]\r
1204         public class Stack\r
1205         {\r
1206             private IStack<int> list;\r
1207 \r
1208 \r
1209             [SetUp]\r
1210             public void Init() { list = new LinkedList<int>(); }\r
1211 \r
1212 \r
1213             [Test]\r
1214             public void Normal()\r
1215             {\r
1216                 list.Push(7);\r
1217                 list.Push(5);\r
1218                 list.Push(7);\r
1219                 list.Push(8);\r
1220                 list.Push(9);\r
1221                 Assert.AreEqual(9, list.Pop());\r
1222                 Assert.AreEqual(8, list.Pop());\r
1223                 Assert.AreEqual(7, list.Pop());\r
1224                 Assert.AreEqual(5, list.Pop());\r
1225                 Assert.AreEqual(7, list.Pop());\r
1226             }\r
1227 \r
1228 \r
1229             [Test]\r
1230             [ExpectedException(typeof(InvalidOperationException))]\r
1231             public void PopEmpty()\r
1232             {\r
1233                 list.Push(5);\r
1234                 Assert.AreEqual(5, list.Pop());\r
1235                 list.Pop();\r
1236             }\r
1237 \r
1238 \r
1239             [TearDown]\r
1240             public void Dispose() { list = null; }\r
1241         }\r
1242         [TestFixture]\r
1243         public class Queue\r
1244         {\r
1245             private IQueue<int> list;\r
1246 \r
1247 \r
1248             [SetUp]\r
1249             public void Init() { list = new LinkedList<int>(); }\r
1250 \r
1251 \r
1252             [Test]\r
1253             public void Normal()\r
1254             {\r
1255                 list.EnQueue(7);\r
1256                 list.EnQueue(5);\r
1257                 list.EnQueue(7);\r
1258                 list.EnQueue(8);\r
1259                 list.EnQueue(9);\r
1260                 Assert.AreEqual(7, list.DeQueue());\r
1261                 Assert.AreEqual(5, list.DeQueue());\r
1262                 Assert.AreEqual(7, list.DeQueue());\r
1263                 Assert.AreEqual(8, list.DeQueue());\r
1264                 Assert.AreEqual(9, list.DeQueue());\r
1265             }\r
1266 \r
1267 \r
1268             [Test]\r
1269             [ExpectedException(typeof(InvalidOperationException))]\r
1270             public void DeQueueEmpty()\r
1271             {\r
1272                 list.EnQueue(5);\r
1273                 Assert.AreEqual(5, list.DeQueue());\r
1274                 list.DeQueue();\r
1275             }\r
1276 \r
1277 \r
1278             [TearDown]\r
1279             public void Dispose() { list = null; }\r
1280         }\r
1281     }\r
1282 \r
1283 \r
1284     namespace Range\r
1285         {\r
1286                 [TestFixture]\r
1287                 public class Range\r
1288                 {\r
1289                         private IList<int> lst;\r
1290 \r
1291 \r
1292                         [SetUp]\r
1293                         public void Init() { lst = new LinkedList<int>(); }\r
1294 \r
1295 \r
1296                         [TearDown]\r
1297                         public void Dispose() { lst = null; }\r
1298 \r
1299 \r
1300                         [Test]\r
1301                         public void GetRange()\r
1302                         {\r
1303                                 //Assert.IsTrue(IC.eq(lst[0, 0)));\r
1304                                 for (int i = 0; i < 10; i++) lst.Add(i);\r
1305 \r
1306                                 Assert.IsTrue(IC.eq(lst[0, 3], 0, 1, 2));\r
1307                                 Assert.IsTrue(IC.eq(lst[3, 4], 3, 4, 5, 6));\r
1308                                 Assert.IsTrue(IC.eq(lst[6, 4], 6, 7, 8, 9));\r
1309                         }\r
1310 \r
1311 \r
1312                         [Test]\r
1313                         [ExpectedException(typeof(ArgumentException))]\r
1314                         public void BadGetRange()\r
1315                         {\r
1316                                 object foo= lst[0, 11];\r
1317                         }\r
1318 \r
1319 \r
1320                         [Test]\r
1321                         public void Backwards()\r
1322                         {\r
1323                                 for (int i = 0; i < 10; i++) lst.Add(i);\r
1324 \r
1325                                 Assert.IsTrue(IC.eq(lst.Backwards(), 9, 8, 7, 6, 5, 4, 3, 2, 1, 0));\r
1326                                 Assert.IsTrue(IC.eq(lst[0, 4].Backwards(), 3, 2, 1, 0));\r
1327                                 Assert.IsTrue(IC.eq(lst[3, 4].Backwards(), 6, 5, 4, 3));\r
1328                                 Assert.IsTrue(IC.eq(lst[6, 4].Backwards(), 9, 8, 7, 6));\r
1329                         }\r
1330 \r
1331 \r
1332                         [Test]\r
1333                         public void DirectionAndCount()\r
1334                         {\r
1335                                 for (int i = 0; i < 10; i++) lst.Add(i);\r
1336 \r
1337                                 Assert.AreEqual(EnumerationDirection.Forwards, lst.Direction);\r
1338                                 Assert.AreEqual(EnumerationDirection.Forwards, lst[3, 7].Direction);\r
1339                                 Assert.AreEqual(EnumerationDirection.Backwards, lst[3, 7].Backwards().Direction);\r
1340                                 Assert.AreEqual(EnumerationDirection.Backwards, lst.Backwards().Direction);\r
1341                                 Assert.AreEqual(4, lst[3, 4].Count);\r
1342                                 Assert.AreEqual(4, lst[3, 4].Backwards().Count);\r
1343                                 Assert.AreEqual(10, lst.Backwards().Count);\r
1344                         }\r
1345 \r
1346 \r
1347                         [Test]\r
1348                         [ExpectedException(typeof(InvalidOperationException))]\r
1349                         public void MoveNextAfterUpdate()\r
1350                         {\r
1351                                 for (int i = 0; i < 10; i++) lst.Add(i);\r
1352 \r
1353                                 foreach (int i in lst)\r
1354                                 {\r
1355                                         lst.Add(45 + i);\r
1356                                 }\r
1357                         }\r
1358                 }\r
1359         }\r
1360 \r
1361 \r
1362 \r
1363 \r
1364         namespace View\r
1365         {\r
1366                 [TestFixture]\r
1367                 public class Simple\r
1368                 {\r
1369                         LinkedList<int> list, view;\r
1370 \r
1371 \r
1372                         [SetUp]\r
1373                         public void Init()\r
1374                         {\r
1375                                 list = new LinkedList<int>();\r
1376                                 list.Add(0);list.Add(1);list.Add(2);list.Add(3);\r
1377                                 view = (LinkedList<int>)list.View(1, 2);\r
1378                         }\r
1379 \r
1380 \r
1381                         [TearDown]\r
1382                         public void Dispose()\r
1383                         {\r
1384                                 list = view = null;\r
1385                         }\r
1386 \r
1387 \r
1388                         void check()\r
1389                         {\r
1390                                 Assert.IsTrue(list.Check());\r
1391                                 Assert.IsTrue(view.Check());\r
1392                         }\r
1393 \r
1394                         [Test]\r
1395                         [ExpectedException(typeof(ArgumentException), "Target item not found")]\r
1396                         public void BadInsertAfterLow()\r
1397                         {\r
1398                                 view.InsertAfter(876, 0);\r
1399                         }\r
1400 \r
1401 \r
1402                         [Test]\r
1403                         [ExpectedException(typeof(ArgumentException), "Target item not found")]\r
1404                         public void BadInsertAfterHigh()\r
1405                         {\r
1406                                 view.InsertAfter(876, 0);\r
1407                         }\r
1408 \r
1409 \r
1410                         [Test]\r
1411                         [ExpectedException(typeof(ArgumentException), "Target item not found")]\r
1412                         public void BadInsertBeforeLow()\r
1413                         {\r
1414                                 view.InsertBefore(876, 0);\r
1415                         }\r
1416 \r
1417 \r
1418                         [Test]\r
1419                         [ExpectedException(typeof(ArgumentException), "Target item not found")]\r
1420                         public void BadInsertBeforeHigh()\r
1421                         {\r
1422                                 view.InsertBefore(876, 0);\r
1423                         }\r
1424 \r
1425 \r
1426 \r
1427                         [Test]\r
1428                         public void Add()\r
1429                         {\r
1430                                 check();\r
1431                                 Assert.IsTrue(IC.eq(list, 0, 1, 2, 3));\r
1432                                 Assert.IsTrue(IC.eq(view, 1, 2));\r
1433                                 view.InsertFirst(10);\r
1434                                 check();\r
1435                                 Assert.IsTrue(IC.eq(list, 0, 10, 1, 2, 3));\r
1436                                 Assert.IsTrue(IC.eq(view, 10, 1, 2));\r
1437                                 view.Clear();\r
1438                                 Assert.IsFalse(view.IsReadOnly);\r
1439                                 Assert.IsTrue(view.AllowsDuplicates);\r
1440                                 Assert.IsTrue(view.IsEmpty);\r
1441                                 check();\r
1442                                 Assert.IsTrue(IC.eq(list, 0, 3));\r
1443                                 Assert.IsTrue(IC.eq(view));\r
1444                                 view.Add(8);\r
1445                                 Assert.IsFalse(view.IsEmpty);\r
1446                                 Assert.IsTrue(view.AllowsDuplicates);\r
1447                                 Assert.IsFalse(view.IsReadOnly);\r
1448                                 check();\r
1449                                 Assert.IsTrue(IC.eq(list, 0, 8, 3));\r
1450                                 Assert.IsTrue(IC.eq(view, 8));\r
1451                                 view.Add(12);\r
1452                                 check();\r
1453                                 Assert.IsTrue(IC.eq(list, 0, 8, 12, 3));\r
1454                                 Assert.IsTrue(IC.eq(view, 8, 12));\r
1455                                 view.InsertAfter(15, 12);\r
1456                                 check();\r
1457                                 Assert.IsTrue(IC.eq(list, 0, 8, 12, 15, 3));\r
1458                                 Assert.IsTrue(IC.eq(view, 8, 12, 15));\r
1459                                 view.InsertBefore(18, 12);\r
1460                                 check();\r
1461                                 Assert.IsTrue(IC.eq(list, 0, 8, 18, 12, 15, 3));\r
1462                                 Assert.IsTrue(IC.eq(view, 8, 18, 12, 15));\r
1463 \r
1464                                 LinkedList<int> lst2 = new LinkedList<int>();\r
1465 \r
1466                                 lst2.Add(90);lst2.Add(92);\r
1467                                 view.AddAll(lst2);\r
1468                                 check();\r
1469                                 Assert.IsTrue(IC.eq(list, 0, 8, 18, 12, 15, 90, 92, 3));\r
1470                                 Assert.IsTrue(IC.eq(view, 8, 18, 12, 15, 90, 92));\r
1471                                 view.InsertLast(66);\r
1472                                 check();\r
1473                                 Assert.IsTrue(IC.eq(list, 0, 8, 18, 12, 15, 90, 92, 66, 3));\r
1474                                 Assert.IsTrue(IC.eq(view, 8, 18, 12, 15, 90, 92, 66));\r
1475                         }\r
1476 \r
1477 \r
1478                         [Test]\r
1479                         public void Bxxx()\r
1480                         {\r
1481                                 Assert.IsTrue(IC.eq(view.Backwards(), 2, 1));\r
1482                 Assert.AreSame(list, view.Underlying);\r
1483                 Assert.IsNull(list.Underlying);\r
1484                 Assert.AreEqual(EnumerationDirection.Forwards, view.Direction);\r
1485                                 Assert.AreEqual(EnumerationDirection.Backwards, view.Backwards().Direction);\r
1486                                 Assert.AreEqual(0,list.Offset);\r
1487                                 Assert.AreEqual(1,view.Offset);\r
1488                         }\r
1489 \r
1490 \r
1491                         [Test]\r
1492                         public void Contains()\r
1493                         {\r
1494                                 Assert.IsTrue(view.Contains(1));\r
1495                                 Assert.IsFalse(view.Contains(0));\r
1496 \r
1497                                 LinkedList<int> lst2 = new LinkedList<int>();\r
1498 \r
1499                                 lst2.Add(2);\r
1500                                 Assert.IsTrue(view.ContainsAll(lst2));\r
1501                                 lst2.Add(3);\r
1502                                 Assert.IsFalse(view.ContainsAll(lst2));\r
1503                                 Assert.AreEqual(Speed.Linear, view.ContainsSpeed);\r
1504                                 Assert.AreEqual(2, view.Count);\r
1505                                 view.Add(1);\r
1506                                 Assert.AreEqual(1, view.ContainsCount(2));\r
1507                                 Assert.AreEqual(2, view.ContainsCount(1));\r
1508                                 Assert.AreEqual(3, view.Count);\r
1509                         }\r
1510 \r
1511 \r
1512                         [Test]\r
1513                         public void CreateView()\r
1514                         {\r
1515                                 LinkedList<int> view2 = (LinkedList<int>)view.View(1, 0);\r
1516 \r
1517                 Assert.AreSame(list, view2.Underlying);\r
1518             }\r
1519 \r
1520 \r
1521                         [Test]\r
1522                         public void FIFO()\r
1523                         {\r
1524                                 Assert.IsTrue(view.FIFO);\r
1525                                 view.Add(23);view.Add(24);view.Add(25);\r
1526                                 check();\r
1527                                 Assert.IsTrue(IC.eq(view, 1, 2, 23, 24, 25));\r
1528                                 Assert.AreEqual(1, view.Remove());\r
1529                                 check();\r
1530                                 Assert.IsTrue(IC.eq(view, 2, 23, 24, 25));\r
1531                                 view.FIFO = false;\r
1532                                 Assert.IsFalse(view.FIFO);\r
1533                                 Assert.AreEqual(25, view.Remove());\r
1534                                 check();\r
1535                                 Assert.IsTrue(IC.eq(view, 2, 23, 24));\r
1536                         }\r
1537 \r
1538 \r
1539                         [Test]\r
1540                         public void MapEtc()\r
1541                         {\r
1542 #if FIXME\r
1543                                 LinkedList<double> dbl = (LinkedList<double>)view.Map(new Mapper<int,double>(delegate(int i){return i/10.0;}));\r
1544 \r
1545                                 Assert.IsTrue(dbl.Check());\r
1546                                 Assert.AreEqual(0.1, dbl[0]);\r
1547                                 Assert.AreEqual(0.2, dbl[1]);\r
1548                                 for (int i = 0; i < 10; i++) view.Add(i);\r
1549 \r
1550                                 list = (LinkedList<int>)view.FindAll(new Filter<int>(delegate(int i){return i%4==1;}));\r
1551                                 Assert.IsTrue(list.Check());\r
1552                                 Assert.IsTrue(IC.eq(list, 1, 1, 5, 9));\r
1553 #endif\r
1554                         }\r
1555 \r
1556 \r
1557                         [Test]\r
1558                         public void FL()\r
1559                         {\r
1560                                 Assert.AreEqual(1, view.First);\r
1561                                 Assert.AreEqual(2, view.Last);\r
1562                         }\r
1563 \r
1564 \r
1565                         [Test]\r
1566                         public void Indexing()\r
1567                         {\r
1568                                 list.Clear();\r
1569                                 for (int i = 0; i < 20; i++) list.Add(i);\r
1570 \r
1571                                 view = (LinkedList<int>)list.View(5, 7);\r
1572                                 for (int i = 0; i < 7; i++) Assert.AreEqual(i + 5, view[i]);\r
1573 \r
1574                                 for (int i = 0; i < 7; i++) Assert.AreEqual(i, view.IndexOf(i + 5));\r
1575 \r
1576                                 for (int i = 0; i < 7; i++) Assert.AreEqual(i, view.LastIndexOf(i + 5));\r
1577                         }\r
1578 \r
1579 \r
1580                         [Test]\r
1581                         public void INsert()\r
1582                         {\r
1583                                 view.Insert(0, 34);\r
1584                                 view.Insert(1, 35);\r
1585                                 view.Insert(4, 36);\r
1586                                 Assert.IsTrue(view.Check());\r
1587                                 Assert.IsTrue(IC.eq(view, 34, 35, 1, 2, 36));\r
1588 \r
1589                                 IList<int> list2 = new LinkedList<int>();\r
1590 \r
1591                                 list2.AddAll(view);\r
1592                                 view.InsertAll(3, list2);\r
1593                                 Assert.IsTrue(view.Check());\r
1594                                 Assert.IsTrue(IC.eq(view, 34, 35, 1, 34, 35, 1, 2, 36, 2, 36));\r
1595                         }\r
1596 \r
1597 \r
1598                         [Test]\r
1599                         public void Sort()\r
1600                         {\r
1601                                 view.Add(45);view.Add(47);view.Add(46);view.Add(48);\r
1602                                 Assert.IsFalse(view.IsSorted(new IC()));\r
1603                                 view.Sort(new IC());\r
1604                                 check();\r
1605                                 Assert.IsTrue(IC.eq(list, 0, 1, 2, 45, 46, 47, 48, 3));\r
1606                                 Assert.IsTrue(IC.eq(view, 1, 2, 45, 46, 47, 48));\r
1607                         }\r
1608 \r
1609 \r
1610                         [Test]\r
1611                         public void Remove()\r
1612                         {\r
1613                                 view.Add(1);view.Add(5);view.Add(3);view.Add(1);view.Add(3);view.Add(0);\r
1614                                 Assert.IsTrue(IC.eq(view, 1, 2, 1, 5, 3, 1, 3, 0));\r
1615                                 Assert.IsTrue(view.Remove(1));\r
1616                                 check();\r
1617                                 Assert.IsTrue(IC.eq(view, 2, 1, 5, 3, 1, 3, 0));\r
1618                                 Assert.IsTrue(view.Remove(1));\r
1619                                 check();\r
1620                                 Assert.IsTrue(IC.eq(view, 2, 5, 3, 1, 3, 0));\r
1621                                 Assert.IsTrue(view.Remove(0));\r
1622                                 check();\r
1623                                 Assert.IsTrue(IC.eq(view, 2, 5, 3, 1, 3));\r
1624                                 view.RemoveAllCopies(3);\r
1625                                 check();\r
1626                                 Assert.IsTrue(IC.eq(view, 2, 5, 1));\r
1627                                 Assert.IsTrue(IC.eq(list, 0, 2, 5, 1, 3));\r
1628                                 view.Add(1);view.Add(5);view.Add(3);view.Add(1);view.Add(3);view.Add(0);\r
1629                                 Assert.IsTrue(IC.eq(view, 2, 5, 1, 1, 5, 3, 1, 3, 0));\r
1630 \r
1631                                 LinkedList<int> l2 = new LinkedList<int>();\r
1632 \r
1633                                 l2.Add(1);l2.Add(2);l2.Add(2);l2.Add(3);l2.Add(1);\r
1634                                 view.RemoveAll(l2);\r
1635                                 check();\r
1636                                 Assert.IsTrue(IC.eq(view, 5, 5, 1, 3, 0));\r
1637                                 view.RetainAll(l2);\r
1638                                 check();\r
1639                                 Assert.IsTrue(IC.eq(view, 1, 3));\r
1640                                 view.Add(2);view.Add(4);view.Add(5);\r
1641                                 Assert.AreEqual(1, view.RemoveAt(0));\r
1642                                 Assert.AreEqual(5, view.RemoveAt(3));\r
1643                                 Assert.AreEqual(2, view.RemoveAt(1));\r
1644                                 check();\r
1645                                 Assert.IsTrue(IC.eq(view, 3, 4));\r
1646                                 view.Add(8);\r
1647                                 Assert.AreEqual(3, view.RemoveFirst());\r
1648                                 Assert.AreEqual(8, view.RemoveLast());\r
1649                                 view.Add(2);view.Add(5);view.Add(3);view.Add(1);\r
1650                                 view.RemoveInterval(1, 2);\r
1651                                 check();\r
1652                                 Assert.IsTrue(IC.eq(view, 4, 3, 1));\r
1653                         }\r
1654 \r
1655 \r
1656                         [Test]\r
1657                         public void Reverse()\r
1658                         {\r
1659                                 view.Clear();\r
1660                                 for (int i = 0; i < 10; i++) view.Add(10 + i);\r
1661 \r
1662                                 view.Reverse(3, 4);\r
1663                                 check();\r
1664                                 Assert.IsTrue(IC.eq(view, 10, 11, 12, 16, 15, 14, 13, 17, 18, 19));\r
1665                                 view.Reverse();\r
1666                                 Assert.IsTrue(IC.eq(view, 19, 18, 17, 13, 14, 15, 16, 12, 11, 10));\r
1667                                 Assert.IsTrue(IC.eq(list, 0, 19, 18, 17, 13, 14, 15, 16, 12, 11, 10, 3));\r
1668                         }\r
1669 \r
1670 \r
1671                         [Test]\r
1672                         public void Slide()\r
1673                         {\r
1674                                 view.Slide(1);\r
1675                                 check();\r
1676                                 Assert.IsTrue(IC.eq(view, 2, 3));\r
1677                                 view.Slide(-2);\r
1678                                 check();\r
1679                                 Assert.IsTrue(IC.eq(view, 0, 1));\r
1680                                 view.Slide(0, 3);\r
1681                                 check();\r
1682                                 Assert.IsTrue(IC.eq(view, 0, 1, 2));\r
1683                                 view.Slide(2, 1);\r
1684                                 check();\r
1685                                 Assert.IsTrue(IC.eq(view, 2));\r
1686                                 view.Slide(-1, 0);\r
1687                                 check();\r
1688                                 Assert.IsTrue(IC.eq(view));\r
1689                                 view.Add(28);\r
1690                                 Assert.IsTrue(IC.eq(list, 0, 28, 1, 2, 3));\r
1691                         }\r
1692                         [Test]\r
1693                         public void Iterate()\r
1694                         {\r
1695                                 list.Clear();\r
1696                                 view = null;\r
1697                                 foreach (int i in new int[] { 2, 4, 8, 13, 6, 1, 2, 7 }) list.Add(i);\r
1698 \r
1699                                 view = (LinkedList<int>)list.View(list.Count - 2, 2);\r
1700                                 while (true)\r
1701                                 {\r
1702                                         //Console.WriteLine("View: {0}:  {1} --> {2}", view.Count, view.First, view.Last);\r
1703                                         if ((view.Last - view.First) % 2 == 1)\r
1704                                                 view.Insert(1, 666);\r
1705                                         check();\r
1706                                         if (view.Offset == 0)\r
1707                                                 break;\r
1708                                         else\r
1709                                                 view.Slide(-1,2);\r
1710                                 }\r
1711                                 //foreach (int i in list) Console.Write(" " + i);\r
1712                                 //Assert.IsTrue(list.Check());\r
1713                                 Assert.IsTrue(IC.eq(list, 2, 4, 8, 666, 13, 6, 1, 666, 2, 666, 7));\r
1714                         }\r
1715 \r
1716 \r
1717                         [Test]\r
1718                         public void SyncRoot()\r
1719                         {\r
1720                                 Assert.AreSame(view.SyncRoot, list.SyncRoot);\r
1721                         }\r
1722                 }\r
1723         }\r
1724 \r
1725 \r
1726 \r
1727 \r
1728         namespace LinkedListOfTreesORLists\r
1729         {\r
1730                 [TestFixture]\r
1731                 public class MultiLevelUnorderedOfUnOrdered\r
1732                 {\r
1733                         private ICollection<int> dit, dat, dut;\r
1734 \r
1735                         private ICollection<ICollection<int>> Dit, Dat, Dut;\r
1736 \r
1737 \r
1738                         [SetUp]\r
1739                         public void Init()\r
1740                         {\r
1741                                 dit = new LinkedList<int>();\r
1742                                 dat = new TreeSet<int>(new IC());\r
1743                                 dut = new LinkedList<int>();\r
1744                                 dit.Add(2);dit.Add(1);\r
1745                                 dat.Add(1);dat.Add(2);\r
1746                                 dut.Add(3);\r
1747                                 Dit = new LinkedList<ICollection<int>>();\r
1748                                 Dat = new LinkedList<ICollection<int>>();\r
1749                                 Dut = new LinkedList<ICollection<int>>();\r
1750                         }\r
1751 \r
1752 \r
1753                         [Test]\r
1754                         public void Check()\r
1755                         {\r
1756                                 Assert.IsTrue(dit.Equals(dat));\r
1757                                 Assert.IsFalse(dit.Equals(dut));\r
1758                         }\r
1759 \r
1760 \r
1761                         [Test]\r
1762                         public void Multi()\r
1763                         {\r
1764                                 Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
1765                                 Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
1766                                 Assert.IsTrue(Dit.Equals(Dat));\r
1767                                 Assert.IsFalse(Dit.Equals(Dut));\r
1768                         }\r
1769 \r
1770 \r
1771                         [TearDown]\r
1772                         public void Dispose()\r
1773                         {\r
1774                                 dit = dat = dut = null;\r
1775                                 Dit = Dat = Dut = null;\r
1776                         }\r
1777                 }\r
1778 \r
1779 \r
1780 \r
1781                 [TestFixture]\r
1782                 public class MultiLevelOrderedOfUnOrdered\r
1783                 {\r
1784                         private ICollection<int> dit, dat, dut;\r
1785 \r
1786                         private ISequenced<ICollection<int>> Dit, Dat, Dut;\r
1787 \r
1788 \r
1789                         [SetUp]\r
1790                         public void Init()\r
1791                         {\r
1792                                 dit = new LinkedList<int>();\r
1793                                 dat = new TreeSet<int>(new IC());\r
1794                                 dut = new LinkedList<int>();\r
1795                                 dit.Add(2);dit.Add(1);\r
1796                                 dat.Add(1);dat.Add(2);\r
1797                                 dut.Add(3);\r
1798                                 Dit = new LinkedList<ICollection<int>>();\r
1799                                 Dat = new LinkedList<ICollection<int>>();\r
1800                                 Dut = new LinkedList<ICollection<int>>();\r
1801                         }\r
1802 \r
1803 \r
1804                         [Test]\r
1805                         public void Check()\r
1806                         {\r
1807                                 Assert.IsTrue(dit.Equals(dat));\r
1808                                 Assert.IsFalse(dit.Equals(dut));\r
1809                         }\r
1810 \r
1811 \r
1812                         [Test]\r
1813                         public void Multi()\r
1814                         {\r
1815                                 Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
1816                                 Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
1817                                 Dut.Add(dit);Dut.Add(dut);Dut.Add(dat);\r
1818                                 Assert.IsFalse(Dit.Equals(Dat));\r
1819                                 Assert.IsTrue(Dit.Equals(Dut));\r
1820                         }\r
1821 \r
1822 \r
1823                         [TearDown]\r
1824                         public void Dispose()\r
1825                         {\r
1826                                 dit = dat = dut = null;\r
1827                                 Dit = Dat = Dut = null;\r
1828                         }\r
1829                 }\r
1830 \r
1831 \r
1832 \r
1833                 [TestFixture]\r
1834                 public class MultiLevelUnOrderedOfOrdered\r
1835                 {\r
1836                         private ISequenced<int> dit, dat, dut, dot;\r
1837 \r
1838                         private ICollection<ISequenced<int>> Dit, Dat, Dut, Dot;\r
1839 \r
1840 \r
1841                         [SetUp]\r
1842                         public void Init()\r
1843                         {\r
1844                                 dit = new TreeSet<int>(new IC());\r
1845                                 dat = new LinkedList<int>();\r
1846                                 dut = new LinkedList<int>();\r
1847                                 dot = new LinkedList<int>();\r
1848                                 dit.Add(2);dit.Add(1);\r
1849                                 dat.Add(2);dat.Add(1);\r
1850                                 dut.Add(3);\r
1851                                 dot.Add(1);dot.Add(2);\r
1852                                 Dit = new LinkedList<ISequenced<int>>();\r
1853                                 Dat = new LinkedList<ISequenced<int>>();\r
1854                                 Dut = new LinkedList<ISequenced<int>>();\r
1855                                 Dot = new LinkedList<ISequenced<int>>();\r
1856                         }\r
1857 \r
1858 \r
1859                         [Test]\r
1860                         public void Check()\r
1861                         {\r
1862                                 Assert.IsFalse(dit.Equals(dat));\r
1863                                 Assert.IsTrue(dit.Equals(dot));\r
1864                                 Assert.IsFalse(dit.Equals(dut));\r
1865                         }\r
1866 \r
1867 \r
1868                         [Test]\r
1869                         public void Multi()\r
1870                         {\r
1871                                 Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
1872                                 Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
1873                                 Dut.Add(dot);Dut.Add(dut);Dut.Add(dit);\r
1874                                 Dot.Add(dit);Dot.Add(dit);Dot.Add(dut);\r
1875                                 Assert.IsTrue(Dit.Equals(Dut));\r
1876                                 Assert.IsFalse(Dit.Equals(Dat));\r
1877                                 Assert.IsTrue(Dit.Equals(Dot));\r
1878                         }\r
1879 \r
1880 \r
1881                         [TearDown]\r
1882                         public void Dispose()\r
1883                         {\r
1884                                 dit = dat = dut = dot = null;\r
1885                                 Dit = Dat = Dut = Dot = null;\r
1886                         }\r
1887                 }\r
1888 \r
1889 \r
1890 \r
1891                 [TestFixture]\r
1892                 public class MultiLevelOrderedOfOrdered\r
1893                 {\r
1894                         private ISequenced<int> dit, dat, dut, dot;\r
1895 \r
1896                         private ISequenced<ISequenced<int>> Dit, Dat, Dut, Dot;\r
1897 \r
1898 \r
1899                         [SetUp]\r
1900                         public void Init()\r
1901                         {\r
1902                                 dit = new TreeSet<int>(new IC());\r
1903                                 dat = new LinkedList<int>();\r
1904                                 dut = new LinkedList<int>();\r
1905                                 dot = new LinkedList<int>();\r
1906                                 dit.Add(2);dit.Add(1);\r
1907                                 dat.Add(2);dat.Add(1);\r
1908                                 dut.Add(3);\r
1909                                 dot.Add(1);dot.Add(2);\r
1910                                 Dit = new LinkedList<ISequenced<int>>();\r
1911                                 Dat = new LinkedList<ISequenced<int>>();\r
1912                                 Dut = new LinkedList<ISequenced<int>>();\r
1913                                 Dot = new LinkedList<ISequenced<int>>();\r
1914                         }\r
1915 \r
1916 \r
1917                         [Test]\r
1918                         public void Check()\r
1919                         {\r
1920                                 Assert.IsFalse(dit.Equals(dat));\r
1921                                 Assert.IsTrue(dit.Equals(dot));\r
1922                                 Assert.IsFalse(dit.Equals(dut));\r
1923                         }\r
1924 \r
1925 \r
1926                         [Test]\r
1927                         public void Multi()\r
1928                         {\r
1929                                 Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
1930                                 Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
1931                                 Dut.Add(dot);Dut.Add(dut);Dut.Add(dit);\r
1932                                 Dot.Add(dit);Dot.Add(dit);Dot.Add(dut);\r
1933                                 Assert.IsTrue(Dit.Equals(Dut));\r
1934                                 Assert.IsFalse(Dit.Equals(Dat));\r
1935                                 Assert.IsFalse(Dit.Equals(Dot));\r
1936                         }\r
1937 \r
1938 \r
1939                         [TearDown]\r
1940                         public void Dispose()\r
1941                         {\r
1942                                 dit = dat = dut = dot = null;\r
1943                                 Dit = Dat = Dut = Dot = null;\r
1944                         }\r
1945                 }\r
1946         }\r
1947 \r
1948 \r
1949 \r
1950 \r
1951         namespace HashingAndEquals\r
1952         {\r
1953                 [TestFixture]\r
1954                 public class ISequenced\r
1955                 {\r
1956                         private ISequenced<int> dit, dat, dut;\r
1957 \r
1958 \r
1959                         [SetUp]\r
1960                         public void Init()\r
1961                         {\r
1962                                 dit = new LinkedList<int>();\r
1963                                 dat = new LinkedList<int>();\r
1964                                 dut = new LinkedList<int>();\r
1965                         }\r
1966 \r
1967 \r
1968                         [Test]\r
1969                         public void EmptyEmpty()\r
1970                         {\r
1971                                 Assert.IsTrue(dit.Equals(dat));\r
1972                         }\r
1973 \r
1974 \r
1975                         [Test]\r
1976                         public void EmptyNonEmpty()\r
1977                         {\r
1978                                 dit.Add(3);\r
1979                                 Assert.IsFalse(dit.Equals(dat));\r
1980                                 Assert.IsFalse(dat.Equals(dit));\r
1981                         }\r
1982 \r
1983 \r
1984                         public int hasher(params int[] items)\r
1985                         {\r
1986                                 int retval = 0;\r
1987 \r
1988                                 foreach (int i in items)\r
1989                                         retval = retval * 31 + i;\r
1990 \r
1991                                 return retval;\r
1992                         }\r
1993 \r
1994 \r
1995                         [Test]\r
1996                         public void HashVal()\r
1997                         {\r
1998                                 Assert.AreEqual(hasher(), dit.GetHashCode());\r
1999                                 dit.Add(3);\r
2000                                 Assert.AreEqual(hasher(3), dit.GetHashCode());\r
2001                                 dit.Add(7);\r
2002                                 Assert.AreEqual(hasher(3, 7), dit.GetHashCode());\r
2003                                 Assert.AreEqual(hasher(), dut.GetHashCode());\r
2004                                 dut.Add(7);\r
2005                                 Assert.AreEqual(hasher(7), dut.GetHashCode());\r
2006                                 dut.Add(3);\r
2007                                 Assert.AreEqual(hasher(7, 3), dut.GetHashCode());\r
2008                         }\r
2009 \r
2010 \r
2011                         [Test]\r
2012                         public void EqualHashButDifferent()\r
2013                         {\r
2014                                 dit.Add(0);dit.Add(31);\r
2015                                 dat.Add(1);dat.Add(0);\r
2016                                 Assert.AreEqual(dit.GetHashCode(), dat.GetHashCode());\r
2017                                 Assert.IsFalse(dit.Equals(dat));\r
2018                         }\r
2019 \r
2020 \r
2021                         [Test]\r
2022                         public void Normal()\r
2023                         {\r
2024                                 dit.Add(3);\r
2025                                 dit.Add(7);\r
2026                                 dat.Add(3);\r
2027                                 Assert.IsFalse(dit.Equals(dat));\r
2028                                 Assert.IsFalse(dat.Equals(dit));\r
2029                                 dat.Add(7);\r
2030                                 Assert.IsTrue(dit.Equals(dat));\r
2031                                 Assert.IsTrue(dat.Equals(dit));\r
2032                         }\r
2033 \r
2034 \r
2035                         [Test]\r
2036                         public void WrongOrder()\r
2037                         {\r
2038                                 dit.Add(3);\r
2039                                 dut.Add(3);\r
2040                                 Assert.IsTrue(dit.Equals(dut));\r
2041                                 Assert.IsTrue(dut.Equals(dit));\r
2042                                 dit.Add(7);\r
2043                                 ((LinkedList<int>)dut).InsertFirst(7);\r
2044                                 Assert.IsFalse(dit.Equals(dut));\r
2045                                 Assert.IsFalse(dut.Equals(dit));\r
2046                         }\r
2047 \r
2048 \r
2049                         [Test]\r
2050                         public void Reflexive()\r
2051                         {\r
2052                                 Assert.IsTrue(dit.Equals(dit));\r
2053                                 dit.Add(3);\r
2054                                 Assert.IsTrue(dit.Equals(dit));\r
2055                                 dit.Add(7);\r
2056                                 Assert.IsTrue(dit.Equals(dit));\r
2057                         }\r
2058 \r
2059 \r
2060                         [TearDown]\r
2061                         public void Dispose()\r
2062                         {\r
2063                                 dit = null;\r
2064                                 dat = null;\r
2065                                 dut = null;\r
2066                         }\r
2067                 }\r
2068 \r
2069 \r
2070 \r
2071                 [TestFixture]\r
2072                 public class IEditableCollection\r
2073                 {\r
2074                         private ICollection<int> dit, dat, dut;\r
2075 \r
2076 \r
2077                         [SetUp]\r
2078                         public void Init()\r
2079                         {\r
2080                                 dit = new LinkedList<int>();\r
2081                                 dat = new LinkedList<int>();\r
2082                                 dut = new LinkedList<int>();\r
2083                         }\r
2084 \r
2085 \r
2086                         [Test]\r
2087                         public void EmptyEmpty()\r
2088                         {\r
2089                                 Assert.IsTrue(dit.Equals(dat));\r
2090                         }\r
2091 \r
2092 \r
2093                         [Test]\r
2094                         public void EmptyNonEmpty()\r
2095                         {\r
2096                                 dit.Add(3);\r
2097                                 Assert.IsFalse(dit.Equals(dat));\r
2098                                 Assert.IsFalse(dat.Equals(dit));\r
2099                         }\r
2100 \r
2101 \r
2102                         public int hasher(int count, params int[] items)\r
2103                         {\r
2104                                 int retval = 0;\r
2105 \r
2106                                 foreach (int i in items)\r
2107                                         retval ^= i;\r
2108 \r
2109                                 return (count << 16) + retval;\r
2110                         }\r
2111 \r
2112 \r
2113                         [Test]\r
2114                         public void HashVal()\r
2115                         {\r
2116                                 Assert.AreEqual(hasher(0), dit.GetHashCode());\r
2117                                 dit.Add(3);\r
2118                                 Assert.AreEqual(hasher(1, 3), dit.GetHashCode());\r
2119                                 dit.Add(7);\r
2120                                 Assert.AreEqual(hasher(2, 3, 7), dit.GetHashCode());\r
2121                                 Assert.AreEqual(hasher(0), dut.GetHashCode());\r
2122                                 dut.Add(3);\r
2123                                 Assert.AreEqual(hasher(1, 3), dut.GetHashCode());\r
2124                                 dut.Add(7);\r
2125                                 Assert.AreEqual(hasher(2, 7, 3), dut.GetHashCode());\r
2126                         }\r
2127 \r
2128 \r
2129                         [Test]\r
2130                         public void EqualHashButDifferent()\r
2131                         {\r
2132                                 dit.Add(2);dit.Add(1);\r
2133                                 dat.Add(3);dat.Add(0);\r
2134                                 Assert.AreEqual(dit.GetHashCode(), dat.GetHashCode());\r
2135                                 Assert.IsFalse(dit.Equals(dat));\r
2136                         }\r
2137 \r
2138 \r
2139                         [Test]\r
2140                         public void Normal()\r
2141                         {\r
2142                                 dit.Add(3);\r
2143                                 dit.Add(7);\r
2144                                 dat.Add(3);\r
2145                                 Assert.IsFalse(dit.Equals(dat));\r
2146                                 Assert.IsFalse(dat.Equals(dit));\r
2147                                 dat.Add(7);\r
2148                                 Assert.IsTrue(dit.Equals(dat));\r
2149                                 Assert.IsTrue(dat.Equals(dit));\r
2150                         }\r
2151 \r
2152 \r
2153                         [Test]\r
2154                         public void WrongOrder()\r
2155                         {\r
2156                                 dit.Add(3);\r
2157                                 dut.Add(3);\r
2158                                 Assert.IsTrue(dit.Equals(dut));\r
2159                                 Assert.IsTrue(dut.Equals(dit));\r
2160                                 dit.Add(7);\r
2161                                 dut.Add(7);\r
2162                                 Assert.IsTrue(dit.Equals(dut));\r
2163                                 Assert.IsTrue(dut.Equals(dit));\r
2164                         }\r
2165 \r
2166 \r
2167                         [Test]\r
2168                         public void Reflexive()\r
2169                         {\r
2170                                 Assert.IsTrue(dit.Equals(dit));\r
2171                                 dit.Add(3);\r
2172                                 Assert.IsTrue(dit.Equals(dit));\r
2173                                 dit.Add(7);\r
2174                                 Assert.IsTrue(dit.Equals(dit));\r
2175                         }\r
2176 \r
2177 \r
2178                         [TearDown]\r
2179                         public void Dispose()\r
2180                         {\r
2181                                 dit = null;\r
2182                                 dat = null;\r
2183                                 dut = null;\r
2184                         }\r
2185                 }\r
2186 \r
2187 \r
2188 \r
2189                 [TestFixture]\r
2190                 public class MultiLevelUnorderedOfUnOrdered\r
2191                 {\r
2192                         private ICollection<int> dit, dat, dut;\r
2193 \r
2194                         private ICollection<ICollection<int>> Dit, Dat, Dut;\r
2195 \r
2196 \r
2197                         [SetUp]\r
2198                         public void Init()\r
2199                         {\r
2200                                 dit = new LinkedList<int>();\r
2201                                 dat = new LinkedList<int>();\r
2202                                 dut = new LinkedList<int>();\r
2203                                 dit.Add(2);dit.Add(1);\r
2204                                 dat.Add(1);dat.Add(2);\r
2205                                 dut.Add(3);\r
2206                                 Dit = new LinkedList<ICollection<int>>();\r
2207                                 Dat = new LinkedList<ICollection<int>>();\r
2208                                 Dut = new LinkedList<ICollection<int>>();\r
2209                         }\r
2210 \r
2211 \r
2212                         [Test]\r
2213                         public void Check()\r
2214                         {\r
2215                                 Assert.IsTrue(dit.Equals(dat));\r
2216                                 Assert.IsFalse(dit.Equals(dut));\r
2217                         }\r
2218 \r
2219 \r
2220                         [Test]\r
2221                         public void Multi()\r
2222                         {\r
2223                                 Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
2224                                 Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
2225                                 Assert.IsTrue(Dit.Equals(Dat));\r
2226                                 Assert.IsFalse(Dit.Equals(Dut));\r
2227                         }\r
2228 \r
2229 \r
2230                         [TearDown]\r
2231                         public void Dispose()\r
2232                         {\r
2233                                 dit = dat = dut = null;\r
2234                                 Dit = Dat = Dut = null;\r
2235                         }\r
2236                 }\r
2237 \r
2238 \r
2239 \r
2240                 [TestFixture]\r
2241                 public class MultiLevelOrderedOfUnOrdered\r
2242                 {\r
2243                         private ICollection<int> dit, dat, dut;\r
2244 \r
2245                         private ISequenced<ICollection<int>> Dit, Dat, Dut;\r
2246 \r
2247 \r
2248                         [SetUp]\r
2249                         public void Init()\r
2250                         {\r
2251                                 dit = new LinkedList<int>();\r
2252                                 dat = new LinkedList<int>();\r
2253                                 dut = new LinkedList<int>();\r
2254                                 dit.Add(2);dit.Add(1);\r
2255                                 dat.Add(1);dat.Add(2);\r
2256                                 dut.Add(3);\r
2257                                 Dit = new LinkedList<ICollection<int>>();\r
2258                                 Dat = new LinkedList<ICollection<int>>();\r
2259                                 Dut = new LinkedList<ICollection<int>>();\r
2260                         }\r
2261 \r
2262 \r
2263                         [Test]\r
2264                         public void Check()\r
2265                         {\r
2266                                 Assert.IsTrue(dit.Equals(dat));\r
2267                                 Assert.IsFalse(dit.Equals(dut));\r
2268                         }\r
2269 \r
2270 \r
2271                         [Test]\r
2272                         public void Multi()\r
2273                         {\r
2274                                 Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
2275                                 Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
2276                                 Dut.Add(dit);Dut.Add(dut);Dut.Add(dat);\r
2277                                 Assert.IsFalse(Dit.Equals(Dat));\r
2278                                 Assert.IsTrue(Dit.Equals(Dut));\r
2279                         }\r
2280 \r
2281 \r
2282                         [TearDown]\r
2283                         public void Dispose()\r
2284                         {\r
2285                                 dit = dat = dut = null;\r
2286                                 Dit = Dat = Dut = null;\r
2287                         }\r
2288                 }\r
2289 \r
2290 \r
2291 \r
2292                 [TestFixture]\r
2293                 public class MultiLevelUnOrderedOfOrdered\r
2294                 {\r
2295                         private ISequenced<int> dit, dat, dut, dot;\r
2296 \r
2297                         private ICollection<ISequenced<int>> Dit, Dat, Dut, Dot;\r
2298 \r
2299 \r
2300                         [SetUp]\r
2301                         public void Init()\r
2302                         {\r
2303                                 dit = new LinkedList<int>();\r
2304                                 dat = new LinkedList<int>();\r
2305                                 dut = new LinkedList<int>();\r
2306                                 dot = new LinkedList<int>();\r
2307                                 dit.Add(2);dit.Add(1);\r
2308                                 dat.Add(1);dat.Add(2);\r
2309                                 dut.Add(3);\r
2310                                 dot.Add(2);dot.Add(1);\r
2311                                 Dit = new LinkedList<ISequenced<int>>();\r
2312                                 Dat = new LinkedList<ISequenced<int>>();\r
2313                                 Dut = new LinkedList<ISequenced<int>>();\r
2314                                 Dot = new LinkedList<ISequenced<int>>();\r
2315                         }\r
2316 \r
2317 \r
2318                         [Test]\r
2319                         public void Check()\r
2320                         {\r
2321                                 Assert.IsFalse(dit.Equals(dat));\r
2322                                 Assert.IsTrue(dit.Equals(dot));\r
2323                                 Assert.IsFalse(dit.Equals(dut));\r
2324                         }\r
2325 \r
2326 \r
2327                         [Test]\r
2328                         public void Multi()\r
2329                         {\r
2330                                 Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
2331                                 Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
2332                                 Dut.Add(dot);Dut.Add(dut);Dut.Add(dit);\r
2333                                 Dot.Add(dit);Dot.Add(dit);Dot.Add(dut);\r
2334                                 Assert.IsTrue(Dit.Equals(Dut));\r
2335                                 Assert.IsFalse(Dit.Equals(Dat));\r
2336                                 Assert.IsTrue(Dit.Equals(Dot));\r
2337                         }\r
2338 \r
2339 \r
2340                         [TearDown]\r
2341                         public void Dispose()\r
2342                         {\r
2343                                 dit = dat = dut = dot = null;\r
2344                                 Dit = Dat = Dut = Dot = null;\r
2345                         }\r
2346                 }\r
2347 \r
2348 \r
2349 \r
2350                 [TestFixture]\r
2351                 public class MultiLevelOrderedOfOrdered\r
2352                 {\r
2353                         private ISequenced<int> dit, dat, dut, dot;\r
2354 \r
2355                         private ISequenced<ISequenced<int>> Dit, Dat, Dut, Dot;\r
2356 \r
2357 \r
2358                         [SetUp]\r
2359                         public void Init()\r
2360                         {\r
2361                                 dit = new LinkedList<int>();\r
2362                                 dat = new LinkedList<int>();\r
2363                                 dut = new LinkedList<int>();\r
2364                                 dot = new LinkedList<int>();\r
2365                                 dit.Add(2);dit.Add(1);\r
2366                                 dat.Add(1);dat.Add(2);\r
2367                                 dut.Add(3);\r
2368                                 dot.Add(2);dot.Add(1);\r
2369                                 Dit = new LinkedList<ISequenced<int>>();\r
2370                                 Dat = new LinkedList<ISequenced<int>>();\r
2371                                 Dut = new LinkedList<ISequenced<int>>();\r
2372                                 Dot = new LinkedList<ISequenced<int>>();\r
2373                         }\r
2374 \r
2375 \r
2376                         [Test]\r
2377                         public void Check()\r
2378                         {\r
2379                                 Assert.IsFalse(dit.Equals(dat));\r
2380                                 Assert.IsTrue(dit.Equals(dot));\r
2381                                 Assert.IsFalse(dit.Equals(dut));\r
2382                         }\r
2383 \r
2384 \r
2385                         [Test]\r
2386                         public void Multi()\r
2387                         {\r
2388                                 Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
2389                                 Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
2390                                 Dut.Add(dot);Dut.Add(dut);Dut.Add(dit);\r
2391                                 Dot.Add(dit);Dot.Add(dit);Dot.Add(dut);\r
2392                                 Assert.IsTrue(Dit.Equals(Dut));\r
2393                                 Assert.IsFalse(Dit.Equals(Dat));\r
2394                                 Assert.IsFalse(Dit.Equals(Dot));\r
2395                         }\r
2396 \r
2397 \r
2398                         [TearDown]\r
2399                         public void Dispose()\r
2400                         {\r
2401                                 dit = dat = dut = dot = null;\r
2402                                 Dit = Dat = Dut = Dot = null;\r
2403                         }\r
2404                 }\r
2405         }\r
2406 }