-#if NET_2_0\r
/*\r
- Copyright (c) 2003-2004 Niels Kokholm <kokholm@itu.dk> and Peter Sestoft <sestoft@dina.kvl.dk>\r
+ Copyright (c) 2003-2006 Niels Kokholm and Peter Sestoft\r
Permission is hereby granted, free of charge, to any person obtaining a copy\r
of this software and associated documentation files (the "Software"), to deal\r
in the Software without restriction, including without limitation the rights\r
using System;\r
using C5;\r
using NUnit.Framework;\r
-using MSG = System.Collections.Generic;\r
+using SCG = System.Collections.Generic;\r
\r
\r
-namespace nunit.linkedlists.plain\r
+namespace C5UnitTests.linkedlists.plain\r
{\r
- namespace Enumerable\r
- {\r
- [TestFixture]\r
- public class Multiops\r
- {\r
- private LinkedList<int> list;\r
-\r
- private Filter<int> always, never, even;\r
-\r
-\r
- [SetUp]\r
- public void Init()\r
- {\r
- list = new LinkedList<int>();\r
- always = delegate{return true;};\r
- never = delegate{return false;};\r
- even = delegate(int i){return i%2==0;};\r
- }\r
-\r
-\r
- [Test]\r
- public void All()\r
- {\r
- Assert.IsTrue(list.All(always));\r
- Assert.IsTrue(list.All(never));\r
- Assert.IsTrue(list.All(even));\r
- list.Add(8);\r
- Assert.IsTrue(list.All(always));\r
- Assert.IsFalse(list.All(never));\r
- Assert.IsTrue(list.All(even));\r
- list.Add(5);\r
- Assert.IsTrue(list.All(always));\r
- Assert.IsFalse(list.All(never));\r
- Assert.IsFalse(list.All(even));\r
- }\r
-\r
-\r
- [Test]\r
- public void Exists()\r
- {\r
- Assert.IsFalse(list.Exists(always));\r
- Assert.IsFalse(list.Exists(never));\r
- Assert.IsFalse(list.Exists(even));\r
- list.Add(5);\r
- Assert.IsTrue(list.Exists(always));\r
- Assert.IsFalse(list.Exists(never));\r
- Assert.IsFalse(list.Exists(even));\r
- list.Add(8);\r
- Assert.IsTrue(list.Exists(always));\r
- Assert.IsFalse(list.Exists(never));\r
- Assert.IsTrue(list.Exists(even));\r
- }\r
-\r
-\r
- [Test]\r
- public void Apply()\r
- {\r
- int sum = 0;\r
- Applier<int> a = delegate(int i){sum=i+10*sum;};\r
-\r
- list.Apply(a);\r
- Assert.AreEqual(0, sum);\r
- sum = 0;\r
- list.Add(5);list.Add(8);list.Add(7);list.Add(5);\r
- list.Apply(a);\r
- Assert.AreEqual(5875, sum);\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose() { list = null; }\r
- }\r
-\r
-\r
-\r
- [TestFixture]\r
- public class GetEnumerator\r
- {\r
- private LinkedList<int> list;\r
-\r
-\r
- [SetUp]\r
- public void Init() { list = new LinkedList<int>(); }\r
-\r
-\r
- [Test]\r
- public void Empty()\r
- {\r
- MSG.IEnumerator<int> e = list.GetEnumerator();\r
-\r
- Assert.IsFalse(e.MoveNext());\r
- }\r
-\r
-\r
- [Test]\r
- public void Normal()\r
- {\r
- list.Add(5);\r
- list.Add(8);\r
- list.Add(5);\r
- list.Add(5);\r
- list.Add(10);\r
- list.Add(1);\r
-\r
- MSG.IEnumerator<int> e = list.GetEnumerator();\r
-\r
- Assert.IsTrue(e.MoveNext());\r
- Assert.AreEqual(5, e.Current);\r
- Assert.IsTrue(e.MoveNext());\r
- Assert.AreEqual(8, e.Current);\r
- Assert.IsTrue(e.MoveNext());\r
- Assert.AreEqual(5, e.Current);\r
- Assert.IsTrue(e.MoveNext());\r
- Assert.AreEqual(5, e.Current);\r
- Assert.IsTrue(e.MoveNext());\r
- Assert.AreEqual(10, e.Current);\r
- Assert.IsTrue(e.MoveNext());\r
- Assert.AreEqual(1, e.Current);\r
- Assert.IsFalse(e.MoveNext());\r
- }\r
-\r
-\r
- [Test]\r
- public void DoDispose()\r
- {\r
- list.Add(5);\r
- list.Add(8);\r
- list.Add(5);\r
+ using CollectionOfInt = LinkedList<int>;\r
\r
- MSG.IEnumerator<int> e = list.GetEnumerator();\r
+ [TestFixture]\r
+ public class GenericTesters\r
+ {\r
\r
- e.MoveNext();\r
- e.MoveNext();\r
- e.Dispose();\r
- }\r
+ [Test]\r
+ public void TestEvents()\r
+ {\r
+ Fun<CollectionOfInt> factory = delegate() { return new CollectionOfInt(TenEqualityComparer.Default); };\r
+ new C5UnitTests.Templates.Events.ListTester<CollectionOfInt>().Test(factory);\r
+ new C5UnitTests.Templates.Events.QueueTester<CollectionOfInt>().Test(factory);\r
+ new C5UnitTests.Templates.Events.StackTester<CollectionOfInt>().Test(factory);\r
+ }\r
\r
+ [Test]\r
+ public void Extensible()\r
+ {\r
+ C5UnitTests.Templates.Extensible.Clone.Tester<CollectionOfInt>();\r
+ C5UnitTests.Templates.Extensible.Clone.ViewTester<CollectionOfInt>();\r
+ C5UnitTests.Templates.Extensible.Serialization.Tester<CollectionOfInt>();\r
+ C5UnitTests.Templates.Extensible.Serialization.ViewTester<CollectionOfInt>();\r
+ }\r
+ }\r
\r
- [Test]\r
- [ExpectedException(typeof(InvalidOperationException))]\r
- public void MoveNextAfterUpdate()\r
- {\r
- list.Add(5);\r
- list.Add(8);\r
- list.Add(5);\r
+ static class Factory\r
+ {\r
+ public static ICollection<T> New<T>() { return new LinkedList<T>(); }\r
+ }\r
\r
- MSG.IEnumerator<int> e = list.GetEnumerator();\r
+ namespace Enumerable\r
+ {\r
+ [TestFixture]\r
+ public class Multiops\r
+ {\r
+ private LinkedList<int> list;\r
+\r
+ private Fun<int, bool> always, never, even;\r
+\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ list = new LinkedList<int>();\r
+ always = delegate { return true; };\r
+ never = delegate { return false; };\r
+ even = delegate(int i) { return i % 2 == 0; };\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void All()\r
+ {\r
+ Assert.IsTrue(list.All(always));\r
+ Assert.IsTrue(list.All(never));\r
+ Assert.IsTrue(list.All(even));\r
+ list.Add(8);\r
+ Assert.IsTrue(list.All(always));\r
+ Assert.IsFalse(list.All(never));\r
+ Assert.IsTrue(list.All(even));\r
+ list.Add(5);\r
+ Assert.IsTrue(list.All(always));\r
+ Assert.IsFalse(list.All(never));\r
+ Assert.IsFalse(list.All(even));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Exists()\r
+ {\r
+ Assert.IsFalse(list.Exists(always));\r
+ Assert.IsFalse(list.Exists(never));\r
+ Assert.IsFalse(list.Exists(even));\r
+ list.Add(5);\r
+ Assert.IsTrue(list.Exists(always));\r
+ Assert.IsFalse(list.Exists(never));\r
+ Assert.IsFalse(list.Exists(even));\r
+ list.Add(8);\r
+ Assert.IsTrue(list.Exists(always));\r
+ Assert.IsFalse(list.Exists(never));\r
+ Assert.IsTrue(list.Exists(even));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Apply()\r
+ {\r
+ int sum = 0;\r
+ Act<int> a = delegate(int i) { sum = i + 10 * sum; };\r
+\r
+ list.Apply(a);\r
+ Assert.AreEqual(0, sum);\r
+ sum = 0;\r
+ list.Add(5); list.Add(8); list.Add(7); list.Add(5);\r
+ list.Apply(a);\r
+ Assert.AreEqual(5875, sum);\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose() { list = null; }\r
+ }\r
\r
- e.MoveNext();\r
- list.Add(99);\r
- e.MoveNext();\r
- }\r
\r
\r
- [TearDown]\r
- public void Dispose() { list = null; }\r
- }\r
- }\r
+ [TestFixture]\r
+ public class GetEnumerator\r
+ {\r
+ private LinkedList<int> list;\r
\r
\r
+ [SetUp]\r
+ public void Init() { list = new LinkedList<int>(); }\r
\r
\r
- namespace CollectionOrExtensible\r
- {\r
- [TestFixture]\r
- public class CollectionOrSink\r
- {\r
- private LinkedList<int> list;\r
+ [Test]\r
+ public void Empty()\r
+ {\r
+ SCG.IEnumerator<int> e = list.GetEnumerator();\r
\r
+ Assert.IsFalse(e.MoveNext());\r
+ }\r
\r
- [SetUp]\r
- public void Init() { list = new LinkedList<int>(); }\r
\r
+ [Test]\r
+ public void Normal()\r
+ {\r
+ list.Add(5);\r
+ list.Add(8);\r
+ list.Add(5);\r
+ list.Add(5);\r
+ list.Add(10);\r
+ list.Add(1);\r
\r
- [Test]\r
- public void CountEtAl()\r
- {\r
- Assert.AreEqual(0, list.Count);\r
- Assert.IsTrue(list.IsEmpty);\r
- Assert.IsTrue(list.AllowsDuplicates);\r
- list.Add(5);\r
- Assert.AreEqual(1, list.Count);\r
- Assert.IsFalse(list.IsEmpty);\r
- list.Add(5);\r
- Assert.AreEqual(2, list.Count);\r
- Assert.IsFalse(list.IsEmpty);\r
- list.Add(8);\r
- Assert.AreEqual(3, list.Count);\r
- }\r
-\r
-\r
- [Test]\r
- public void AddAll()\r
- {\r
- list.Add(3);list.Add(4);list.Add(5);\r
-\r
- LinkedList<int> list2 = new LinkedList<int>();\r
-\r
- list2.AddAll(list);\r
- Assert.IsTrue(IC.eq(list2, 3, 4, 5));\r
- list.AddAll(list2);\r
- Assert.IsTrue(IC.eq(list2, 3, 4, 5));\r
- Assert.IsTrue(IC.eq(list, 3, 4, 5, 3, 4, 5));\r
- }\r
+ SCG.IEnumerator<int> e = list.GetEnumerator();\r
\r
-\r
- [TearDown]\r
- public void Dispose() { list = null; }\r
- }\r
+ Assert.IsTrue(e.MoveNext());\r
+ Assert.AreEqual(5, e.Current);\r
+ Assert.IsTrue(e.MoveNext());\r
+ Assert.AreEqual(8, e.Current);\r
+ Assert.IsTrue(e.MoveNext());\r
+ Assert.AreEqual(5, e.Current);\r
+ Assert.IsTrue(e.MoveNext());\r
+ Assert.AreEqual(5, e.Current);\r
+ Assert.IsTrue(e.MoveNext());\r
+ Assert.AreEqual(10, e.Current);\r
+ Assert.IsTrue(e.MoveNext());\r
+ Assert.AreEqual(1, e.Current);\r
+ Assert.IsFalse(e.MoveNext());\r
+ }\r
\r
\r
+ [Test]\r
+ public void DoDispose()\r
+ {\r
+ list.Add(5);\r
+ list.Add(8);\r
+ list.Add(5);\r
\r
- [TestFixture]\r
- public class ArrayTest\r
- {\r
- private LinkedList<int> list;\r
+ SCG.IEnumerator<int> e = list.GetEnumerator();\r
\r
- int[] a;\r
+ e.MoveNext();\r
+ e.MoveNext();\r
+ e.Dispose();\r
+ }\r
\r
\r
- [SetUp]\r
- public void Init()\r
- {\r
- list = new LinkedList<int>();\r
- a = new int[10];\r
- for (int i = 0; i < 10; i++)\r
- a[i] = 1000 + i;\r
- }\r
+ [Test]\r
+ [ExpectedException(typeof(CollectionModifiedException))]\r
+ public void MoveNextAfterUpdate()\r
+ {\r
+ list.Add(5);\r
+ list.Add(8);\r
+ list.Add(5);\r
\r
+ SCG.IEnumerator<int> e = list.GetEnumerator();\r
\r
- [TearDown]\r
- public void Dispose() { list = null; }\r
+ e.MoveNext();\r
+ list.Add(99);\r
+ e.MoveNext();\r
+ }\r
\r
\r
- private string aeq(int[] a, params int[] b)\r
- {\r
- if (a.Length != b.Length)\r
- return "Lengths differ: " + a.Length + " != " + b.Length;\r
+ [TearDown]\r
+ public void Dispose() { list = null; }\r
+ }\r
+ }\r
\r
- for (int i = 0; i < a.Length; i++)\r
- if (a[i] != b[i])\r
- return String.Format("{0}'th elements differ: {1} != {2}", i, a[i], b[i]);\r
+ namespace CollectionOrExtensible\r
+ {\r
+ [TestFixture]\r
+ public class Formatting\r
+ {\r
+ ICollection<int> coll;\r
+ IFormatProvider rad16;\r
+ [SetUp]\r
+ public void Init() { coll = Factory.New<int>(); rad16 = new RadixFormatProvider(16); }\r
+ [TearDown]\r
+ public void Dispose() { coll = null; rad16 = null; }\r
+ [Test]\r
+ public void Format()\r
+ {\r
+ Assert.AreEqual("[ ]", coll.ToString());\r
+ coll.AddAll<int>(new int[] { -4, 28, 129, 65530 });\r
+ Assert.AreEqual("[ -4, 28, 129, 65530 ]", coll.ToString());\r
+ Assert.AreEqual("[ -4, 1C, 81, FFFA ]", coll.ToString(null, rad16));\r
+ Assert.AreEqual("[ -4, 28, 129... ]", coll.ToString("L14", null));\r
+ Assert.AreEqual("[ -4, 1C, 81... ]", coll.ToString("L14", rad16));\r
+ }\r
+ }\r
\r
- return "Alles klar";\r
- }\r
+ [TestFixture]\r
+ public class CollectionOrSink\r
+ {\r
+ private LinkedList<int> list;\r
+\r
+\r
+ [SetUp]\r
+ public void Init() { list = new LinkedList<int>(); }\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(NullReferenceException))]\r
+ public void NullEqualityComparerinConstructor1()\r
+ {\r
+ new LinkedList<int>(null);\r
+ }\r
+\r
+ [Test]\r
+ public void Choose()\r
+ {\r
+ list.Add(7);\r
+ Assert.AreEqual(7, list.Choose());\r
+ }\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(NoSuchItemException))]\r
+ public void BadChoose()\r
+ {\r
+ list.Choose();\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void CountEtAl()\r
+ {\r
+ Assert.AreEqual(0, list.Count);\r
+ Assert.IsTrue(list.IsEmpty);\r
+ Assert.IsTrue(list.AllowsDuplicates);\r
+ list.Add(5);\r
+ Assert.AreEqual(1, list.Count);\r
+ Assert.IsFalse(list.IsEmpty);\r
+ list.Add(5);\r
+ Assert.AreEqual(2, list.Count);\r
+ Assert.IsFalse(list.IsEmpty);\r
+ list.Add(8);\r
+ Assert.AreEqual(3, list.Count);\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void AddAll()\r
+ {\r
+ list.Add(3); list.Add(4); list.Add(5);\r
+\r
+ LinkedList<int> list2 = new LinkedList<int>();\r
+\r
+ list2.AddAll(list);\r
+ Assert.IsTrue(IC.eq(list2, 3, 4, 5));\r
+ list.AddAll(list2);\r
+ Assert.IsTrue(IC.eq(list2, 3, 4, 5));\r
+ Assert.IsTrue(IC.eq(list, 3, 4, 5, 3, 4, 5));\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose() { list = null; }\r
+ }\r
\r
+ [TestFixture]\r
+ public class FindPredicate\r
+ {\r
+ private LinkedList<int> list;\r
+ Fun<int, bool> pred;\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ list = new LinkedList<int>(TenEqualityComparer.Default);\r
+ pred = delegate(int i) { return i % 5 == 0; };\r
+ }\r
+\r
+ [TearDown]\r
+ public void Dispose() { list = null; }\r
+\r
+ [Test]\r
+ public void Find()\r
+ {\r
+ int i;\r
+ Assert.IsFalse(list.Find(pred, out i));\r
+ list.AddAll<int>(new int[] { 4, 22, 67, 37 });\r
+ Assert.IsFalse(list.Find(pred, out i));\r
+ list.AddAll<int>(new int[] { 45, 122, 675, 137 });\r
+ Assert.IsTrue(list.Find(pred, out i));\r
+ Assert.AreEqual(45, i);\r
+ }\r
+\r
+ [Test]\r
+ public void FindLast()\r
+ {\r
+ int i;\r
+ Assert.IsFalse(list.FindLast(pred, out i));\r
+ list.AddAll<int>(new int[] { 4, 22, 67, 37 });\r
+ Assert.IsFalse(list.FindLast(pred, out i));\r
+ list.AddAll<int>(new int[] { 45, 122, 675, 137 });\r
+ Assert.IsTrue(list.FindLast(pred, out i));\r
+ Assert.AreEqual(675, i);\r
+ }\r
+\r
+ [Test]\r
+ public void FindIndex()\r
+ {\r
+ Assert.IsFalse(0 <= list.FindIndex(pred));\r
+ list.AddAll<int>(new int[] { 4, 22, 67, 37 });\r
+ Assert.IsFalse(0 <= list.FindIndex(pred));\r
+ list.AddAll<int>(new int[] { 45, 122, 675, 137 });\r
+ Assert.AreEqual(4, list.FindIndex(pred));\r
+ }\r
+\r
+ [Test]\r
+ public void FindLastIndex()\r
+ {\r
+ Assert.IsFalse(0 <= list.FindLastIndex(pred));\r
+ list.AddAll<int>(new int[] { 4, 22, 67, 37 });\r
+ Assert.IsFalse(0 <= list.FindLastIndex(pred));\r
+ list.AddAll<int>(new int[] { 45, 122, 675, 137 });\r
+ Assert.AreEqual(6, list.FindLastIndex(pred));\r
+ }\r
+ }\r
+\r
+ [TestFixture]\r
+ public class UniqueItems\r
+ {\r
+ private LinkedList<int> list;\r
+\r
+ [SetUp]\r
+ public void Init() { list = new LinkedList<int>(); }\r
+\r
+ [TearDown]\r
+ public void Dispose() { list = null; }\r
+\r
+ [Test]\r
+ public void Test()\r
+ {\r
+ Assert.IsTrue(IC.seteq(list.UniqueItems()));\r
+ Assert.IsTrue(IC.seteq(list.ItemMultiplicities()));\r
+ list.AddAll<int>(new int[] { 7, 9, 7 });\r
+ Assert.IsTrue(IC.seteq(list.UniqueItems(), 7, 9));\r
+ Assert.IsTrue(IC.seteq(list.ItemMultiplicities(), 7, 2, 9, 1));\r
+ }\r
+ }\r
\r
- [Test]\r
- public void ToArray()\r
- {\r
- Assert.AreEqual("Alles klar", aeq(list.ToArray()));\r
- list.Add(7);\r
- list.Add(7);\r
- Assert.AreEqual("Alles klar", aeq(list.ToArray(), 7, 7));\r
- }\r
+ [TestFixture]\r
+ public class ArrayTest\r
+ {\r
+ private LinkedList<int> list;\r
+\r
+ int[] a;\r
+\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ list = new LinkedList<int>();\r
+ a = new int[10];\r
+ for (int i = 0; i < 10; i++)\r
+ a[i] = 1000 + i;\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose() { list = null; }\r
+\r
+\r
+ private string aeq(int[] a, params int[] b)\r
+ {\r
+ if (a.Length != b.Length)\r
+ return "Lengths differ: " + a.Length + " != " + b.Length;\r
+\r
+ for (int i = 0; i < a.Length; i++)\r
+ if (a[i] != b[i])\r
+ return String.Format("{0}'th elements differ: {1} != {2}", i, a[i], b[i]);\r
+\r
+ return "Alles klar";\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void ToArray()\r
+ {\r
+ Assert.AreEqual("Alles klar", aeq(list.ToArray()));\r
+ list.Add(7);\r
+ list.Add(7);\r
+ Assert.AreEqual("Alles klar", aeq(list.ToArray(), 7, 7));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void CopyTo()\r
+ {\r
+ list.CopyTo(a, 1);\r
+ Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009));\r
+ list.Add(6);\r
+ list.CopyTo(a, 2);\r
+ Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 6, 1003, 1004, 1005, 1006, 1007, 1008, 1009));\r
+ list.Add(4);\r
+ list.Add(4);\r
+ list.Add(9);\r
+ list.CopyTo(a, 4);\r
+ Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 6, 1003, 6, 4, 4, 9, 1008, 1009));\r
+ list.Clear();\r
+ list.Add(7);\r
+ list.CopyTo(a, 9);\r
+ Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 6, 1003, 6, 4, 4, 9, 1008, 7));\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
+ public void CopyToBad()\r
+ {\r
+ list.CopyTo(a, 11);\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
+ public void CopyToBad2()\r
+ {\r
+ list.CopyTo(a, -1);\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
+ public void CopyToTooFar()\r
+ {\r
+ list.Add(3);\r
+ list.Add(3);\r
+ list.CopyTo(a, 9);\r
+ }\r
+ }\r
\r
\r
- [Test]\r
- public void CopyTo()\r
- {\r
- list.CopyTo(a, 1);\r
- Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009));\r
- list.Add(6);\r
- list.CopyTo(a, 2);\r
- Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 6, 1003, 1004, 1005, 1006, 1007, 1008, 1009));\r
- list.Add(4);\r
- list.Add(4);\r
- list.Add(9);\r
- list.CopyTo(a, 4);\r
- Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 6, 1003, 6, 4, 4, 9, 1008, 1009));\r
- list.Clear();\r
- list.Add(7);\r
- list.CopyTo(a, 9);\r
- Assert.AreEqual("Alles klar", aeq(a, 1000, 1001, 6, 1003, 6, 4, 4, 9, 1008, 7));\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(ArgumentException))]\r
- public void CopyToBad()\r
- {\r
- list.Add(3);\r
- list.CopyTo(a, 10);\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
- public void CopyToBad2()\r
- {\r
- list.CopyTo(a, -1);\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(ArgumentException))]\r
- public void CopyToTooFar()\r
- {\r
- list.Add(3);\r
- list.Add(3);\r
- list.CopyTo(a, 9);\r
- }\r
- }\r
-\r
-\r
-\r
- [TestFixture]\r
- public class Sync\r
- {\r
- private LinkedList<int> list;\r
-\r
-\r
- [SetUp]\r
- public void Init()\r
- {\r
- list = new LinkedList<int>();\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose() { list = null; }\r
-\r
-\r
- [Test]\r
- public void Get()\r
- {\r
- Assert.IsNotNull(list.SyncRoot);\r
- }\r
- }\r
- }\r
-\r
-\r
-\r
-\r
- namespace EditableCollection\r
- {\r
- [TestFixture]\r
- public class Searching\r
- {\r
- private LinkedList<int> list;\r
-\r
-\r
- [SetUp]\r
- public void Init() { list = new LinkedList<int>(); }\r
-\r
-\r
- [Test]\r
- public void Contains()\r
- {\r
- Assert.IsFalse(list.Contains(5));\r
- list.Add(5);\r
- Assert.IsTrue(list.Contains(5));\r
- Assert.IsFalse(list.Contains(7));\r
- list.Add(8);\r
- list.Add(10);\r
- Assert.IsTrue(list.Contains(5));\r
- Assert.IsFalse(list.Contains(7));\r
- Assert.IsTrue(list.Contains(8));\r
- Assert.IsTrue(list.Contains(10));\r
- list.Remove(8);\r
- Assert.IsTrue(list.Contains(5));\r
- Assert.IsFalse(list.Contains(7));\r
- Assert.IsFalse(list.Contains(8));\r
- Assert.IsTrue(list.Contains(10));\r
- }\r
-\r
-\r
- [Test]\r
- public void ContainsCount()\r
- {\r
- Assert.AreEqual(0, list.ContainsCount(5));\r
- list.Add(5);\r
- Assert.AreEqual(1, list.ContainsCount(5));\r
- Assert.AreEqual(0, list.ContainsCount(7));\r
- list.Add(8);\r
- Assert.AreEqual(1, list.ContainsCount(5));\r
- Assert.AreEqual(0, list.ContainsCount(7));\r
- Assert.AreEqual(1, list.ContainsCount(8));\r
- list.Add(5);\r
- Assert.AreEqual(2, list.ContainsCount(5));\r
- Assert.AreEqual(0, list.ContainsCount(7));\r
- Assert.AreEqual(1, list.ContainsCount(8));\r
- }\r
-\r
-\r
- [Test]\r
- public void RemoveAllCopies()\r
- {\r
- list.Add(5);list.Add(7);list.Add(5);\r
- Assert.AreEqual(2, list.ContainsCount(5));\r
- Assert.AreEqual(1, list.ContainsCount(7));\r
- list.RemoveAllCopies(5);\r
- Assert.AreEqual(0, list.ContainsCount(5));\r
- Assert.AreEqual(1, list.ContainsCount(7));\r
- list.Add(5);list.Add(8);list.Add(5);\r
- list.RemoveAllCopies(8);\r
- Assert.IsTrue(IC.eq(list, 7, 5, 5));\r
- }\r
-\r
-\r
- [Test]\r
- public void FindAll()\r
- {\r
- Filter<int> f = delegate(int i){return i%2==0;};\r
-\r
- Assert.IsTrue(list.FindAll(f).IsEmpty);\r
- list.Add(5);list.Add(8);list.Add(5);list.Add(10);list.Add(8);\r
- Assert.IsTrue(((LinkedList<int>)list.FindAll(f)).Check());\r
- Assert.IsTrue(IC.eq(list.FindAll(f), 8, 10, 8));\r
- }\r
-\r
-\r
- [Test]\r
- public void ContainsAll()\r
- {\r
- LinkedList<int> list2 = new LinkedList<int>();\r
-\r
- Assert.IsTrue(list.ContainsAll(list2));\r
- list2.Add(4);\r
- Assert.IsFalse(list.ContainsAll(list2));\r
- list.Add(4);\r
- Assert.IsTrue(list.ContainsAll(list2));\r
- list.Add(5);\r
- Assert.IsTrue(list.ContainsAll(list2));\r
- list2.Add(4);\r
- Assert.IsFalse(list.ContainsAll(list2));\r
- list.Add(4);\r
- Assert.IsTrue(list.ContainsAll(list2));\r
- }\r
-\r
-\r
- [Test]\r
- public void RetainAll()\r
- {\r
- LinkedList<int> list2 = new LinkedList<int>();\r
-\r
- list.Add(4);list.Add(4);list.Add(5);list.Add(4);list.Add(6);\r
- list2.Add(5);list2.Add(4);list2.Add(7);list2.Add(7);list2.Add(4);\r
- list.RetainAll(list2);\r
- Assert.IsTrue(list.Check());\r
- Assert.IsTrue(IC.eq(list, 4, 4, 5));\r
- list.Add(5);list.Add(4);list.Add(6);\r
- list2.Clear();\r
- list2.Add(5);list2.Add(5);list2.Add(6);\r
- list.RetainAll(list2);\r
- Assert.IsTrue(list.Check());\r
- Assert.IsTrue(IC.eq(list, 5, 5, 6));\r
- list2.Clear();\r
- list2.Add(7);list2.Add(8);list2.Add(9);\r
- list.RetainAll(list2);\r
- Assert.IsTrue(list.Check());\r
- Assert.IsTrue(IC.eq(list));\r
- }\r
-\r
-\r
- [Test]\r
- public void RemoveAll()\r
- {\r
- LinkedList<int> list2 = new LinkedList<int>();\r
-\r
- list.Add(4);list.Add(4);list.Add(5);list.Add(4);list.Add(6);\r
- list2.Add(5);list2.Add(4);list2.Add(7);list2.Add(7);list2.Add(4);\r
- list.RemoveAll(list2);\r
- Assert.IsTrue(list.Check());\r
- Assert.IsTrue(IC.eq(list, 4, 6));\r
- list.Add(5);list.Add(4);list.Add(6);\r
- list2.Clear();\r
- list2.Add(6);list2.Add(5);list2.Add(5);list2.Add(6);\r
- list.RemoveAll(list2);\r
- Assert.IsTrue(list.Check());\r
- Assert.IsTrue(IC.eq(list, 4, 4));\r
- list2.Clear();\r
- list2.Add(7);list2.Add(8);list2.Add(9);\r
- list.RemoveAll(list2);\r
- Assert.IsTrue(list.Check());\r
- Assert.IsTrue(IC.eq(list, 4, 4));\r
- }\r
-\r
-\r
- [Test]\r
- public void Remove()\r
- {\r
- list.Add(4);list.Add(4);list.Add(5);list.Add(4);list.Add(6);\r
- Assert.IsFalse(list.Remove(2));\r
- Assert.IsTrue(list.Check());\r
- Assert.IsTrue(list.Remove(4));\r
- Assert.IsTrue(list.Check());\r
- Assert.IsTrue(IC.eq(list, 4, 5, 4, 6));\r
- Assert.AreEqual(6, list.RemoveLast());\r
- Assert.IsTrue(list.Check());\r
- Assert.IsTrue(IC.eq(list, 4, 5, 4));\r
- list.Add(7);\r
- Assert.AreEqual(4, list.RemoveFirst());\r
- Assert.IsTrue(list.Check());\r
- Assert.IsTrue(IC.eq(list, 5, 4, 7));\r
- }\r
-\r
-\r
- [Test]\r
- public void Clear()\r
- {\r
- list.Add(7);list.Add(7);\r
- list.Clear();\r
- Assert.IsTrue(list.IsEmpty);\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose() { list = null; }\r
- }\r
- }\r
-\r
-\r
-\r
-\r
- namespace IIndexed\r
- {\r
- [TestFixture]\r
- public class Searching\r
- {\r
- private IIndexed<int> dit;\r
-\r
-\r
- [SetUp]\r
- public void Init()\r
- {\r
- dit = new LinkedList<int>();\r
- }\r
-\r
-\r
- [Test]\r
- public void IndexOf()\r
- {\r
- Assert.AreEqual(-1, dit.IndexOf(6));\r
- dit.Add(7);\r
- Assert.AreEqual(-1, dit.IndexOf(6));\r
- Assert.AreEqual(-1, dit.LastIndexOf(6));\r
- Assert.AreEqual(0, dit.IndexOf(7));\r
- dit.Add(5);dit.Add(7);dit.Add(8);dit.Add(7);\r
- Assert.AreEqual(-1, dit.IndexOf(6));\r
- Assert.AreEqual(0, dit.IndexOf(7));\r
- Assert.AreEqual(4, dit.LastIndexOf(7));\r
- Assert.AreEqual(3, dit.IndexOf(8));\r
- Assert.AreEqual(1, dit.LastIndexOf(5));\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose()\r
- {\r
- dit = null;\r
- }\r
- }\r
-\r
-\r
-\r
- [TestFixture]\r
- public class Removing\r
- {\r
- private IIndexed<int> dit;\r
-\r
-\r
- [SetUp]\r
- public void Init()\r
- {\r
- dit = new LinkedList<int>();\r
- }\r
-\r
-\r
- [Test]\r
- public void RemoveAt()\r
- {\r
- dit.Add(5);dit.Add(7);dit.Add(9);dit.Add(1);dit.Add(2);\r
- Assert.AreEqual(7, dit.RemoveAt(1));\r
- Assert.IsTrue(((LinkedList<int>)dit).Check());\r
- Assert.IsTrue(IC.eq(dit, 5, 9, 1, 2));\r
- Assert.AreEqual(5, dit.RemoveAt(0));\r
- Assert.IsTrue(((LinkedList<int>)dit).Check());\r
- Assert.IsTrue(IC.eq(dit, 9, 1, 2));\r
- Assert.AreEqual(2, dit.RemoveAt(2));\r
- Assert.IsTrue(((LinkedList<int>)dit).Check());\r
- Assert.IsTrue(IC.eq(dit, 9, 1));\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(IndexOutOfRangeException))]\r
- public void RemoveAtBad0()\r
- {\r
- dit.RemoveAt(0);\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(IndexOutOfRangeException))]\r
- public void RemoveAtBadM1()\r
- {\r
- dit.RemoveAt(-1);\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(IndexOutOfRangeException))]\r
- public void RemoveAtBad1()\r
- {\r
- dit.Add(8);\r
- dit.RemoveAt(1);\r
- }\r
-\r
-\r
- [Test]\r
- public void RemoveInterval()\r
- {\r
- dit.RemoveInterval(0, 0);\r
- dit.Add(10);dit.Add(20);dit.Add(30);dit.Add(40);dit.Add(50);dit.Add(60);\r
- dit.RemoveInterval(3, 0);\r
- Assert.IsTrue(((LinkedList<int>)dit).Check());\r
- Assert.IsTrue(IC.eq(dit, 10, 20, 30, 40, 50, 60));\r
- dit.RemoveInterval(3, 1);\r
- Assert.IsTrue(((LinkedList<int>)dit).Check());\r
- Assert.IsTrue(IC.eq(dit, 10, 20, 30, 50, 60));\r
- dit.RemoveInterval(1, 3);\r
- Assert.IsTrue(((LinkedList<int>)dit).Check());\r
- Assert.IsTrue(IC.eq(dit, 10, 60));\r
- dit.RemoveInterval(0, 2);\r
- Assert.IsTrue(((LinkedList<int>)dit).Check());\r
- Assert.IsTrue(IC.eq(dit));\r
- dit.Add(10);dit.Add(20);dit.Add(30);dit.Add(40);dit.Add(50);dit.Add(60);\r
- dit.RemoveInterval(0, 2);\r
- Assert.IsTrue(((LinkedList<int>)dit).Check());\r
- Assert.IsTrue(IC.eq(dit, 30, 40, 50, 60));\r
- dit.RemoveInterval(2, 2);\r
- Assert.IsTrue(((LinkedList<int>)dit).Check());\r
- Assert.IsTrue(IC.eq(dit, 30, 40));\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose()\r
- {\r
- dit = null;\r
- }\r
- }\r
- }\r
-\r
-\r
-\r
-\r
- namespace IList\r
- {\r
- [TestFixture]\r
- public class Searching\r
- {\r
- private IList<int> lst;\r
-\r
-\r
- [SetUp]\r
- public void Init() { lst = new LinkedList<int>(); }\r
-\r
-\r
- [TearDown]\r
- public void Dispose() { lst = null; }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(InvalidOperationException), "List is empty")]\r
- public void FirstBad()\r
- {\r
- int f = lst.First;\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(InvalidOperationException), "List is empty")]\r
- public void LastBad()\r
- {\r
- int f = lst.Last;\r
- }\r
-\r
-\r
- [Test]\r
- public void FirstLast()\r
- {\r
- lst.Add(19);\r
- Assert.AreEqual(19, lst.First);\r
- Assert.AreEqual(19, lst.Last);\r
- lst.Add(34);lst.InsertFirst(12);\r
- Assert.AreEqual(12, lst.First);\r
- Assert.AreEqual(34, lst.Last);\r
- }\r
-\r
-\r
- [Test]\r
- public void This()\r
- {\r
- lst.Add(34);\r
- Assert.AreEqual(34, lst[0]);\r
- lst[0] = 56;\r
- Assert.AreEqual(56, lst.First);\r
- lst.Add(7);lst.Add(7);lst.Add(7);lst.Add(7);\r
- lst[0] = 45;lst[2] = 78;lst[4] = 101;\r
- Assert.IsTrue(IC.eq(lst, 45, 7, 78, 7, 101));\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(IndexOutOfRangeException))]\r
- public void ThisBadEmptyGet()\r
- {\r
- int f = lst[0];\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(IndexOutOfRangeException))]\r
- public void ThisBadLowGet()\r
- {\r
- lst.Add(7);\r
-\r
- int f = lst[-1];\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(IndexOutOfRangeException))]\r
- public void ThisBadHiGet()\r
- {\r
- lst.Add(6);\r
\r
- int f = lst[1];\r
- }\r
+ [TestFixture]\r
+ public class Sync\r
+ {\r
+ private LinkedList<int> list;\r
\r
\r
- [Test]\r
- [ExpectedException(typeof(IndexOutOfRangeException))]\r
- public void ThisBadEmptySet()\r
- {\r
- lst[0] = 4;\r
- }\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ list = new LinkedList<int>();\r
+ }\r
\r
\r
- [Test]\r
- [ExpectedException(typeof(IndexOutOfRangeException))]\r
- public void ThisBadLowSet()\r
- {\r
- lst.Add(7);\r
- lst[-1] = 9;\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(IndexOutOfRangeException))]\r
- public void ThisBadHiSet()\r
- {\r
- lst.Add(6);\r
- lst[1] = 11;\r
- }\r
- }\r
-\r
-\r
- [TestFixture]\r
- public class Combined\r
- {\r
- private IList<KeyValuePair<int,int>> lst;\r
-\r
-\r
- [SetUp]\r
- public void Init()\r
- {\r
- lst = new LinkedList<KeyValuePair<int,int>>();\r
- for (int i = 0; i < 10; i++)\r
- lst.Add(new KeyValuePair<int,int>(i, i + 30));\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose() { lst = null; }\r
-\r
-\r
- [Test]\r
- public void Find()\r
- {\r
- KeyValuePair<int,int> p = new KeyValuePair<int,int>(3, 78);\r
-\r
- Assert.IsTrue(lst.Find(ref p));\r
- Assert.AreEqual(3, p.key);\r
- Assert.AreEqual(33, p.value);\r
- p = new KeyValuePair<int,int>(13, 78);\r
- Assert.IsFalse(lst.Find(ref p));\r
- }\r
-\r
-\r
- [Test]\r
- public void FindOrAdd()\r
- {\r
- KeyValuePair<int,int> p = new KeyValuePair<int,int>(3, 78);\r
-\r
- Assert.IsTrue(lst.FindOrAdd(ref p));\r
- Assert.AreEqual(3, p.key);\r
- Assert.AreEqual(33, p.value);\r
- p = new KeyValuePair<int,int>(13, 79);\r
- Assert.IsFalse(lst.FindOrAdd(ref p));\r
- Assert.AreEqual(13, lst[10].key);\r
- Assert.AreEqual(79, lst[10].value);\r
- }\r
-\r
-\r
- [Test]\r
- public void Update()\r
- {\r
- KeyValuePair<int,int> p = new KeyValuePair<int,int>(3, 78);\r
-\r
- Assert.IsTrue(lst.Update(p));\r
- Assert.AreEqual(3, lst[3].key);\r
- Assert.AreEqual(78, lst[3].value);\r
- p = new KeyValuePair<int,int>(13, 78);\r
- Assert.IsFalse(lst.Update(p));\r
- }\r
-\r
-\r
- [Test]\r
- public void UpdateOrAdd()\r
- {\r
- KeyValuePair<int,int> p = new KeyValuePair<int,int>(3, 78);\r
-\r
- Assert.IsTrue(lst.UpdateOrAdd(p));\r
- Assert.AreEqual(3, lst[3].key);\r
- Assert.AreEqual(78, lst[3].value);\r
- p = new KeyValuePair<int,int>(13, 79);\r
- Assert.IsFalse(lst.UpdateOrAdd(p));\r
- Assert.AreEqual(13, lst[10].key);\r
- Assert.AreEqual(79, lst[10].value);\r
- }\r
-\r
-\r
- [Test]\r
- public void RemoveWithReturn()\r
- {\r
- KeyValuePair<int,int> p = new KeyValuePair<int,int>(3, 78);\r
-\r
- Assert.IsTrue(lst.RemoveWithReturn(ref p));\r
- Assert.AreEqual(3, p.key);\r
- Assert.AreEqual(33, p.value);\r
- Assert.AreEqual(4, lst[3].key);\r
- Assert.AreEqual(34, lst[3].value);\r
- p = new KeyValuePair<int,int>(13, 78);\r
- Assert.IsFalse(lst.RemoveWithReturn(ref p));\r
- }\r
- }\r
-\r
-\r
- [TestFixture]\r
- public class Inserting\r
- {\r
- private IList<int> lst;\r
-\r
-\r
- [SetUp]\r
- public void Init() { lst = new LinkedList<int>(); }\r
-\r
-\r
- [TearDown]\r
- public void Dispose() { lst = null; }\r
-\r
-\r
- [Test]\r
- public void Insert()\r
- {\r
- lst.Insert(0, 5);\r
- Assert.IsTrue(IC.eq(lst, 5));\r
- lst.Insert(0, 7);\r
- Assert.IsTrue(IC.eq(lst, 7, 5));\r
- lst.Insert(1, 4);\r
- Assert.IsTrue(IC.eq(lst, 7, 4, 5));\r
- lst.Insert(3, 2);\r
- Assert.IsTrue(IC.eq(lst, 7, 4, 5, 2));\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(IndexOutOfRangeException))]\r
- public void BadInsertLow()\r
- {\r
- lst.Add(7);\r
- lst.Insert(-1, 9);\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(IndexOutOfRangeException))]\r
- public void BadInsertHi()\r
- {\r
- lst.Add(6);\r
- lst.Insert(2, 11);\r
- }\r
-\r
-\r
- [Test]\r
- public void FIFO()\r
- {\r
- for (int i = 0; i < 7; i++)\r
- lst.Add(2 * i);\r
-\r
- Assert.IsTrue(lst.FIFO);\r
- Assert.AreEqual(0, lst.Remove());\r
- Assert.AreEqual(2, lst.Remove());\r
- lst.FIFO = false;\r
- Assert.AreEqual(12, lst.Remove());\r
- Assert.AreEqual(10, lst.Remove());\r
- lst.FIFO = true;\r
- Assert.AreEqual(4, lst.Remove());\r
- Assert.AreEqual(6, lst.Remove());\r
- }\r
-\r
-\r
- [Test]\r
- public void InsertFirstLast()\r
- {\r
- lst.InsertFirst(4);\r
- lst.InsertLast(5);\r
- lst.InsertFirst(14);\r
- lst.InsertLast(15);\r
- lst.InsertFirst(24);\r
- lst.InsertLast(25);\r
- lst.InsertFirst(34);\r
- lst.InsertLast(55);\r
- Assert.IsTrue(IC.eq(lst, 34, 24, 14, 4, 5, 15, 25, 55));\r
- }\r
-\r
-\r
- [Test]\r
- public void InsertBefore()\r
- {\r
- lst.Add(2);\r
- lst.Add(3);\r
- lst.Add(2);\r
- lst.Add(5);\r
- lst.InsertBefore(7, 2);\r
- Assert.IsTrue(lst.Check());\r
- Assert.IsTrue(IC.eq(lst, 7, 2, 3, 2, 5));\r
- lst.InsertBefore(8, 3);\r
- Assert.IsTrue(lst.Check());\r
- Assert.IsTrue(IC.eq(lst, 7, 2, 8, 3, 2, 5));\r
- lst.InsertBefore(9, 5);\r
- Assert.IsTrue(lst.Check());\r
- Assert.IsTrue(IC.eq(lst, 7, 2, 8, 3, 2, 9, 5));\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(ArgumentException), "Target item not found")]\r
- public void BadInsertBefore()\r
- {\r
- lst.Add(2);\r
- lst.Add(3);\r
- lst.Add(2);\r
- lst.Add(5);\r
- lst.InsertBefore(7, 4);\r
- }\r
-\r
-\r
- [Test]\r
- public void InsertAfter()\r
- {\r
- lst.Add(1);\r
- lst.Add(2);\r
- lst.Add(3);\r
- lst.Add(2);\r
- lst.Add(5);\r
- lst.InsertAfter(7, 2);\r
- Assert.IsTrue(lst.Check());\r
- Assert.IsTrue(IC.eq(lst, 1, 2, 3, 2, 7, 5));\r
- lst.InsertAfter(8, 1);\r
- Assert.IsTrue(lst.Check());\r
- Assert.IsTrue(IC.eq(lst, 1, 8, 2, 3, 2, 7, 5));\r
- lst.InsertAfter(9, 5);\r
- Assert.IsTrue(lst.Check());\r
- Assert.IsTrue(IC.eq(lst, 1, 8, 2, 3, 2, 7, 5, 9));\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(ArgumentException), "Target item not found")]\r
- public void BadInsertAfter()\r
- {\r
- lst.Add(2);\r
- lst.Add(3);\r
- lst.Add(2);\r
- lst.Add(5);\r
- lst.InsertAfter(7, 4);\r
- }\r
-\r
-\r
- [Test]\r
- public void InsertAll()\r
- {\r
- lst.Add(1);\r
- lst.Add(2);\r
- lst.Add(3);\r
- lst.Add(4);\r
-\r
- IList<int> lst2 = new LinkedList<int>();\r
-\r
- lst2.Add(7);lst2.Add(8);lst2.Add(9);\r
- lst.InsertAll(0, lst2);\r
- Assert.IsTrue(lst.Check());\r
- Assert.IsTrue(IC.eq(lst, 7, 8, 9, 1, 2, 3, 4));\r
- lst.InsertAll(7, lst2);\r
- Assert.IsTrue(lst.Check());\r
- Assert.IsTrue(IC.eq(lst, 7, 8, 9, 1, 2, 3, 4, 7, 8, 9));\r
- lst.InsertAll(5, lst2);\r
- Assert.IsTrue(lst.Check());\r
- Assert.IsTrue(IC.eq(lst, 7, 8, 9, 1, 2, 7, 8, 9, 3, 4, 7, 8, 9));\r
- }\r
-\r
-\r
- [Test]\r
- public void Map()\r
- {\r
- Mapper<int,string> m = delegate(int i){return "<<"+i+">>";};\r
- IList<string> r = lst.Map(m);\r
-\r
- Assert.IsTrue(r.Check());\r
- Assert.IsTrue(r.IsEmpty);\r
- lst.Add(1);\r
- lst.Add(2);\r
- lst.Add(3);\r
- lst.Add(4);\r
- r = lst.Map(m);\r
- Assert.IsTrue(r.Check());\r
- Assert.AreEqual(4, r.Count);\r
- for (int i = 0; i < 4; i++)\r
- Assert.AreEqual("<<" + (i + 1) + ">>", r[i]);\r
- }\r
-\r
-\r
- [Test]\r
- public void RemoveFirstLast()\r
- {\r
- lst.Add(1);\r
- lst.Add(2);\r
- lst.Add(3);\r
- lst.Add(4);\r
- Assert.AreEqual(1, lst.RemoveFirst());\r
- Assert.AreEqual(4, lst.RemoveLast());\r
- Assert.AreEqual(2, lst.RemoveFirst());\r
- Assert.AreEqual(3, lst.RemoveLast());\r
- Assert.IsTrue(lst.IsEmpty);\r
- }\r
-\r
- [Test]\r
- [ExpectedException(typeof(InvalidOperationException))]\r
- public void RemoveFirstEmpty()\r
- {\r
- lst.RemoveFirst();\r
- }\r
+ [TearDown]\r
+ public void Dispose() { list = null; }\r
\r
- [Test]\r
- [ExpectedException(typeof(InvalidOperationException))]\r
- public void RemoveLastEmpty()\r
- {\r
- lst.RemoveLast();\r
- }\r
\r
- [Test]\r
- public void Reverse()\r
- {\r
- for (int i = 0; i < 10; i++)\r
- lst.Add(i);\r
-\r
- lst.Reverse();\r
- Assert.IsTrue(lst.Check());\r
- Assert.IsTrue(IC.eq(lst, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0));\r
- lst.Reverse(0, 3);\r
- Assert.IsTrue(lst.Check());\r
- Assert.IsTrue(IC.eq(lst, 7, 8, 9, 6, 5, 4, 3, 2, 1, 0));\r
- lst.Reverse(7, 0);\r
- Assert.IsTrue(lst.Check());\r
- Assert.IsTrue(IC.eq(lst, 7, 8, 9, 6, 5, 4, 3, 2, 1, 0));\r
- lst.Reverse(7, 3);\r
- Assert.IsTrue(lst.Check());\r
- Assert.IsTrue(IC.eq(lst, 7, 8, 9, 6, 5, 4, 3, 0, 1, 2));\r
- lst.Reverse(5, 1);\r
- Assert.IsTrue(lst.Check());\r
- Assert.IsTrue(IC.eq(lst, 7, 8, 9, 6, 5, 4, 3, 0, 1, 2));\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(ArgumentException))]\r
- public void BadReverse()\r
- {\r
- for (int i = 0; i < 10; i++)\r
- lst.Add(i);\r
-\r
- lst.Reverse(8, 3);\r
- }\r
- }\r
-\r
-\r
-\r
- [TestFixture]\r
- public class Sorting\r
- {\r
- private IList<int> lst;\r
-\r
-\r
- [SetUp]\r
- public void Init() { lst = new LinkedList<int>(); }\r
-\r
-\r
- [TearDown]\r
- public void Dispose() { lst = null; }\r
-\r
-\r
- [Test]\r
- public void Sort()\r
- {\r
- lst.Add(5);lst.Add(6);lst.Add(5);lst.Add(7);lst.Add(3);\r
- Assert.IsFalse(lst.IsSorted(new IC()));\r
- lst.Sort(new IC());\r
- Assert.IsTrue(lst.Check());\r
- Assert.IsTrue(lst.IsSorted(new IC()));\r
- Assert.IsTrue(IC.eq(lst, 3, 5, 5, 6, 7));\r
- }\r
-\r
-\r
- [Test]\r
- public void Stability()\r
- {\r
- IList<KeyValuePair<int,string>> lst2 = new LinkedList<KeyValuePair<int,string>>();\r
- IComparer<KeyValuePair<int,string>> c = new KeyValuePairComparer<int,string>(new IC());\r
-\r
- lst2.Add(new KeyValuePair<int,string>(5, "a"));\r
- lst2.Add(new KeyValuePair<int,string>(5, "b"));\r
- lst2.Add(new KeyValuePair<int,string>(6, "c"));\r
- lst2.Add(new KeyValuePair<int,string>(4, "d"));\r
- lst2.Add(new KeyValuePair<int,string>(3, "e"));\r
- lst2.Add(new KeyValuePair<int,string>(4, "f"));\r
- lst2.Add(new KeyValuePair<int,string>(5, "h"));\r
- Assert.IsFalse(lst2.IsSorted(c));\r
- lst2.Sort(c);\r
- Assert.IsTrue(lst2.IsSorted(c));\r
-\r
- KeyValuePair<int,string> p = lst2.RemoveFirst();\r
-\r
- Assert.AreEqual(3, p.key);\r
- Assert.AreEqual("e", p.value);\r
- p = lst2.RemoveFirst();\r
- Assert.AreEqual(4, p.key);\r
- Assert.AreEqual("d", p.value);\r
- p = lst2.RemoveFirst();\r
- Assert.AreEqual(4, p.key);\r
- Assert.AreEqual("f", p.value);\r
- p = lst2.RemoveFirst();\r
- Assert.AreEqual(5, p.key);\r
- Assert.AreEqual("a", p.value);\r
- p = lst2.RemoveFirst();\r
- Assert.AreEqual(5, p.key);\r
- Assert.AreEqual("b", p.value);\r
- p = lst2.RemoveFirst();\r
- Assert.AreEqual(5, p.key);\r
- Assert.AreEqual("h", p.value);\r
- p = lst2.RemoveFirst();\r
- Assert.AreEqual(6, p.key);\r
- Assert.AreEqual("c", p.value);\r
- Assert.IsTrue(lst2.IsEmpty);\r
- }\r
- }\r
- }\r
-\r
-\r
- namespace IStackQueue\r
+ [Test]\r
+ public void Get()\r
+ {\r
+ Assert.IsNotNull(list.SyncRoot);\r
+ }\r
+ }\r
+ }\r
+\r
+\r
+\r
+\r
+ namespace EditableCollection\r
+ {\r
+ [TestFixture]\r
+ public class Searching\r
{\r
- [TestFixture]\r
- public class Stack\r
- {\r
- private IStack<int> list;\r
+ private LinkedList<int> list;\r
+\r
+\r
+ [SetUp]\r
+ public void Init() { list = new LinkedList<int>(); }\r
+\r
+\r
+ [Test]\r
+ public void Contains()\r
+ {\r
+ Assert.IsFalse(list.Contains(5));\r
+ list.Add(5);\r
+ Assert.IsTrue(list.Contains(5));\r
+ Assert.IsFalse(list.Contains(7));\r
+ list.Add(8);\r
+ list.Add(10);\r
+ Assert.IsTrue(list.Contains(5));\r
+ Assert.IsFalse(list.Contains(7));\r
+ Assert.IsTrue(list.Contains(8));\r
+ Assert.IsTrue(list.Contains(10));\r
+ list.Remove(8);\r
+ Assert.IsTrue(list.Contains(5));\r
+ Assert.IsFalse(list.Contains(7));\r
+ Assert.IsFalse(list.Contains(8));\r
+ Assert.IsTrue(list.Contains(10));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void ContainsCount()\r
+ {\r
+ Assert.AreEqual(0, list.ContainsCount(5));\r
+ list.Add(5);\r
+ Assert.AreEqual(1, list.ContainsCount(5));\r
+ Assert.AreEqual(0, list.ContainsCount(7));\r
+ list.Add(8);\r
+ Assert.AreEqual(1, list.ContainsCount(5));\r
+ Assert.AreEqual(0, list.ContainsCount(7));\r
+ Assert.AreEqual(1, list.ContainsCount(8));\r
+ list.Add(5);\r
+ Assert.AreEqual(2, list.ContainsCount(5));\r
+ Assert.AreEqual(0, list.ContainsCount(7));\r
+ Assert.AreEqual(1, list.ContainsCount(8));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void RemoveAllCopies()\r
+ {\r
+ list.Add(5); list.Add(7); list.Add(5);\r
+ Assert.AreEqual(2, list.ContainsCount(5));\r
+ Assert.AreEqual(1, list.ContainsCount(7));\r
+ list.RemoveAllCopies(5);\r
+ Assert.AreEqual(0, list.ContainsCount(5));\r
+ Assert.AreEqual(1, list.ContainsCount(7));\r
+ list.Add(5); list.Add(8); list.Add(5);\r
+ list.RemoveAllCopies(8);\r
+ Assert.IsTrue(IC.eq(list, 7, 5, 5));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void FindAll()\r
+ {\r
+ Fun<int, bool> f = delegate(int i) { return i % 2 == 0; };\r
+\r
+ Assert.IsTrue(list.FindAll(f).IsEmpty);\r
+ list.Add(5); list.Add(8); list.Add(5); list.Add(10); list.Add(8);\r
+ Assert.IsTrue(((LinkedList<int>)list.FindAll(f)).Check());\r
+ Assert.IsTrue(IC.eq(list.FindAll(f), 8, 10, 8));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void ContainsAll()\r
+ {\r
+ LinkedList<int> list2 = new LinkedList<int>();\r
+\r
+ Assert.IsTrue(list.ContainsAll(list2));\r
+ list2.Add(4);\r
+ Assert.IsFalse(list.ContainsAll(list2));\r
+ list.Add(4);\r
+ Assert.IsTrue(list.ContainsAll(list2));\r
+ list.Add(5);\r
+ Assert.IsTrue(list.ContainsAll(list2));\r
+ list2.Add(4);\r
+ Assert.IsFalse(list.ContainsAll(list2));\r
+ list.Add(4);\r
+ Assert.IsTrue(list.ContainsAll(list2));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void RetainAll()\r
+ {\r
+ LinkedList<int> list2 = new LinkedList<int>();\r
+\r
+ list.Add(4); list.Add(4); list.Add(5); list.Add(4); list.Add(6);\r
+ list2.Add(5); list2.Add(4); list2.Add(7); list2.Add(7); list2.Add(4);\r
+ list.RetainAll(list2);\r
+ Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(IC.eq(list, 4, 4, 5));\r
+ list.Add(5); list.Add(4); list.Add(6);\r
+ list2.Clear();\r
+ list2.Add(5); list2.Add(5); list2.Add(6);\r
+ list.RetainAll(list2);\r
+ Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(IC.eq(list, 5, 5, 6));\r
+ list2.Clear();\r
+ list2.Add(7); list2.Add(8); list2.Add(9);\r
+ list.RetainAll(list2);\r
+ Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(IC.eq(list));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void RemoveAll()\r
+ {\r
+ LinkedList<int> list2 = new LinkedList<int>();\r
+\r
+ list.Add(4); list.Add(4); list.Add(5); list.Add(4); list.Add(6);\r
+ list2.Add(5); list2.Add(4); list2.Add(7); list2.Add(7); list2.Add(4);\r
+ list.RemoveAll(list2);\r
+ Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(IC.eq(list, 4, 6));\r
+ list.Add(5); list.Add(4); list.Add(6);\r
+ list2.Clear();\r
+ list2.Add(6); list2.Add(5); list2.Add(5); list2.Add(6);\r
+ list.RemoveAll(list2);\r
+ Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(IC.eq(list, 4, 4));\r
+ list2.Clear();\r
+ list2.Add(7); list2.Add(8); list2.Add(9);\r
+ list.RemoveAll(list2);\r
+ Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(IC.eq(list, 4, 4));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Remove()\r
+ {\r
+\r
+ Assert.IsTrue(list.FIFO);\r
+ list.Add(4); list.Add(4); list.Add(5); list.Add(4); list.Add(6);\r
+ Assert.IsFalse(list.Remove(2));\r
+ Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(list.Remove(4));\r
+ Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(IC.eq(list, 4, 5, 4, 6));\r
+ Assert.AreEqual(6, list.RemoveLast());\r
+ Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(IC.eq(list, 4, 5, 4));\r
+ list.Add(7);\r
+ Assert.AreEqual(4, list.RemoveFirst());\r
+ Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(IC.eq(list, 5, 4, 7));\r
+\r
+ list.FIFO = false;\r
+ list.Clear();\r
+ list.Add(4); list.Add(4); list.Add(5); list.Add(4); list.Add(6);\r
+ Assert.IsFalse(list.Remove(2));\r
+ Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(list.Remove(4));\r
+ Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(IC.eq(list, 4, 4, 5, 6));\r
+ Assert.AreEqual(6, list.RemoveLast());\r
+ Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(IC.eq(list, 4, 4, 5));\r
+ list.Add(7);\r
+ Assert.AreEqual(4, list.RemoveFirst());\r
+ Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(IC.eq(list, 4, 5, 7));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Clear()\r
+ {\r
+ list.Add(7); list.Add(7);\r
+ list.Clear();\r
+ Assert.IsTrue(list.IsEmpty);\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose() { list = null; }\r
+ }\r
+ }\r
\r
\r
- [SetUp]\r
- public void Init() { list = new LinkedList<int>(); }\r
\r
\r
- [Test]\r
- public void Normal()\r
- {\r
- list.Push(7);\r
- list.Push(5);\r
- list.Push(7);\r
- list.Push(8);\r
- list.Push(9);\r
- Assert.AreEqual(9, list.Pop());\r
- Assert.AreEqual(8, list.Pop());\r
- Assert.AreEqual(7, list.Pop());\r
- Assert.AreEqual(5, list.Pop());\r
- Assert.AreEqual(7, list.Pop());\r
- }\r
+ namespace IIndexed\r
+ {\r
+ [TestFixture]\r
+ public class Searching\r
+ {\r
+ private IIndexed<int> dit;\r
+\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ dit = new LinkedList<int>();\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void IndexOf()\r
+ {\r
+ Assert.AreEqual(~0, dit.IndexOf(6));\r
+ dit.Add(7);\r
+ Assert.AreEqual(~1, dit.IndexOf(6));\r
+ Assert.AreEqual(~1, dit.LastIndexOf(6));\r
+ Assert.AreEqual(0, dit.IndexOf(7));\r
+ dit.Add(5); dit.Add(7); dit.Add(8); dit.Add(7);\r
+ Assert.AreEqual(~5, dit.IndexOf(6));\r
+ Assert.AreEqual(0, dit.IndexOf(7));\r
+ Assert.AreEqual(4, dit.LastIndexOf(7));\r
+ Assert.AreEqual(3, dit.IndexOf(8));\r
+ Assert.AreEqual(1, dit.LastIndexOf(5));\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose()\r
+ {\r
+ dit = null;\r
+ }\r
+ }\r
\r
\r
- [Test]\r
- [ExpectedException(typeof(InvalidOperationException))]\r
- public void PopEmpty()\r
- {\r
- list.Push(5);\r
- Assert.AreEqual(5, list.Pop());\r
- list.Pop();\r
- }\r
+\r
+ [TestFixture]\r
+ public class Removing\r
+ {\r
+ private IIndexed<int> dit;\r
+\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ dit = new LinkedList<int>();\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void RemoveAt()\r
+ {\r
+ dit.Add(5); dit.Add(7); dit.Add(9); dit.Add(1); dit.Add(2);\r
+ Assert.AreEqual(7, dit.RemoveAt(1));\r
+ Assert.IsTrue(((LinkedList<int>)dit).Check());\r
+ Assert.IsTrue(IC.eq(dit, 5, 9, 1, 2));\r
+ Assert.AreEqual(5, dit.RemoveAt(0));\r
+ Assert.IsTrue(((LinkedList<int>)dit).Check());\r
+ Assert.IsTrue(IC.eq(dit, 9, 1, 2));\r
+ Assert.AreEqual(2, dit.RemoveAt(2));\r
+ Assert.IsTrue(((LinkedList<int>)dit).Check());\r
+ Assert.IsTrue(IC.eq(dit, 9, 1));\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(IndexOutOfRangeException))]\r
+ public void RemoveAtBad0()\r
+ {\r
+ dit.RemoveAt(0);\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(IndexOutOfRangeException))]\r
+ public void RemoveAtBadM1()\r
+ {\r
+ dit.RemoveAt(-1);\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(IndexOutOfRangeException))]\r
+ public void RemoveAtBad1()\r
+ {\r
+ dit.Add(8);\r
+ dit.RemoveAt(1);\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void RemoveInterval()\r
+ {\r
+ dit.RemoveInterval(0, 0);\r
+ dit.Add(10); dit.Add(20); dit.Add(30); dit.Add(40); dit.Add(50); dit.Add(60);\r
+ dit.RemoveInterval(3, 0);\r
+ Assert.IsTrue(((LinkedList<int>)dit).Check());\r
+ Assert.IsTrue(IC.eq(dit, 10, 20, 30, 40, 50, 60));\r
+ dit.RemoveInterval(3, 1);\r
+ Assert.IsTrue(((LinkedList<int>)dit).Check());\r
+ Assert.IsTrue(IC.eq(dit, 10, 20, 30, 50, 60));\r
+ dit.RemoveInterval(1, 3);\r
+ Assert.IsTrue(((LinkedList<int>)dit).Check());\r
+ Assert.IsTrue(IC.eq(dit, 10, 60));\r
+ dit.RemoveInterval(0, 2);\r
+ Assert.IsTrue(((LinkedList<int>)dit).Check());\r
+ Assert.IsTrue(IC.eq(dit));\r
+ dit.Add(10); dit.Add(20); dit.Add(30); dit.Add(40); dit.Add(50); dit.Add(60);\r
+ dit.RemoveInterval(0, 2);\r
+ Assert.IsTrue(((LinkedList<int>)dit).Check());\r
+ Assert.IsTrue(IC.eq(dit, 30, 40, 50, 60));\r
+ dit.RemoveInterval(2, 2);\r
+ Assert.IsTrue(((LinkedList<int>)dit).Check());\r
+ Assert.IsTrue(IC.eq(dit, 30, 40));\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose()\r
+ {\r
+ dit = null;\r
+ }\r
+ }\r
+ }\r
+\r
+\r
+\r
+\r
+ namespace IList_\r
+ {\r
+ [TestFixture]\r
+ public class Searching\r
+ {\r
+ private IList<int> lst;\r
+\r
+\r
+ [SetUp]\r
+ public void Init() { lst = new LinkedList<int>(); }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose() { lst = null; }\r
\r
\r
- [TearDown]\r
- public void Dispose() { list = null; }\r
+ [Test]\r
+ [ExpectedException(typeof(NoSuchItemException))]\r
+ public void FirstBad()\r
+ {\r
+ int f = lst.First;\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(NoSuchItemException))]\r
+ public void LastBad()\r
+ {\r
+ int f = lst.Last;\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void FirstLast()\r
+ {\r
+ lst.Add(19);\r
+ Assert.AreEqual(19, lst.First);\r
+ Assert.AreEqual(19, lst.Last);\r
+ lst.Add(34); lst.InsertFirst(12);\r
+ Assert.AreEqual(12, lst.First);\r
+ Assert.AreEqual(34, lst.Last);\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void This()\r
+ {\r
+ lst.Add(34);\r
+ Assert.AreEqual(34, lst[0]);\r
+ lst[0] = 56;\r
+ Assert.AreEqual(56, lst.First);\r
+ lst.Add(7); lst.Add(7); lst.Add(7); lst.Add(7);\r
+ lst[0] = 45; lst[2] = 78; lst[4] = 101;\r
+ Assert.IsTrue(IC.eq(lst, 45, 7, 78, 7, 101));\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(IndexOutOfRangeException))]\r
+ public void ThisBadEmptyGet()\r
+ {\r
+ int f = lst[0];\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(IndexOutOfRangeException))]\r
+ public void ThisBadLowGet()\r
+ {\r
+ lst.Add(7);\r
+\r
+ int f = lst[-1];\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(IndexOutOfRangeException))]\r
+ public void ThisBadHiGet()\r
+ {\r
+ lst.Add(6);\r
+\r
+ int f = lst[1];\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(IndexOutOfRangeException))]\r
+ public void ThisBadEmptySet()\r
+ {\r
+ lst[0] = 4;\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(IndexOutOfRangeException))]\r
+ public void ThisBadLowSet()\r
+ {\r
+ lst.Add(7);\r
+ lst[-1] = 9;\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(IndexOutOfRangeException))]\r
+ public void ThisBadHiSet()\r
+ {\r
+ lst.Add(6);\r
+ lst[1] = 11;\r
+ }\r
+ }\r
+\r
+\r
+ [TestFixture]\r
+ public class Combined\r
+ {\r
+ private IList<KeyValuePair<int, int>> lst;\r
+\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ lst = new LinkedList<KeyValuePair<int, int>>(new KeyValuePairEqualityComparer<int, int>());\r
+ for (int i = 0; i < 10; i++)\r
+ lst.Add(new KeyValuePair<int, int>(i, i + 30));\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose() { lst = null; }\r
+\r
+\r
+ [Test]\r
+ public void Find()\r
+ {\r
+ KeyValuePair<int, int> p = new KeyValuePair<int, int>(3, 78);\r
+\r
+ Assert.IsTrue(lst.Find(ref p));\r
+ Assert.AreEqual(3, p.Key);\r
+ Assert.AreEqual(33, p.Value);\r
+ p = new KeyValuePair<int, int>(13, 78);\r
+ Assert.IsFalse(lst.Find(ref p));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void FindOrAdd()\r
+ {\r
+ KeyValuePair<int, int> p = new KeyValuePair<int, int>(3, 78);\r
+\r
+ Assert.IsTrue(lst.FindOrAdd(ref p));\r
+ Assert.AreEqual(3, p.Key);\r
+ Assert.AreEqual(33, p.Value);\r
+ p = new KeyValuePair<int, int>(13, 79);\r
+ Assert.IsFalse(lst.FindOrAdd(ref p));\r
+ Assert.AreEqual(13, lst[10].Key);\r
+ Assert.AreEqual(79, lst[10].Value);\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Update()\r
+ {\r
+ KeyValuePair<int, int> p = new KeyValuePair<int, int>(3, 78);\r
+\r
+ Assert.IsTrue(lst.Update(p));\r
+ Assert.AreEqual(3, lst[3].Key);\r
+ Assert.AreEqual(78, lst[3].Value);\r
+ p = new KeyValuePair<int, int>(13, 78);\r
+ Assert.IsFalse(lst.Update(p));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void UpdateOrAdd()\r
+ {\r
+ KeyValuePair<int, int> p = new KeyValuePair<int, int>(3, 78);\r
+\r
+ Assert.IsTrue(lst.UpdateOrAdd(p));\r
+ Assert.AreEqual(3, lst[3].Key);\r
+ Assert.AreEqual(78, lst[3].Value);\r
+ p = new KeyValuePair<int, int>(13, 79);\r
+ Assert.IsFalse(lst.UpdateOrAdd(p));\r
+ Assert.AreEqual(13, lst[10].Key);\r
+ Assert.AreEqual(79, lst[10].Value);\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void RemoveWithReturn()\r
+ {\r
+ KeyValuePair<int, int> p = new KeyValuePair<int, int>(3, 78);\r
+\r
+ Assert.IsTrue(lst.Remove(p, out p));\r
+ Assert.AreEqual(3, p.Key);\r
+ Assert.AreEqual(33, p.Value);\r
+ Assert.AreEqual(4, lst[3].Key);\r
+ Assert.AreEqual(34, lst[3].Value);\r
+ p = new KeyValuePair<int, int>(13, 78);\r
+ Assert.IsFalse(lst.Remove(p, out p));\r
+ }\r
+ }\r
+\r
+\r
+ [TestFixture]\r
+ public class Inserting\r
+ {\r
+ private IList<int> lst;\r
+\r
+\r
+ [SetUp]\r
+ public void Init() { lst = new LinkedList<int>(); }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose() { lst = null; }\r
+\r
+\r
+ [Test]\r
+ public void Insert()\r
+ {\r
+ lst.Insert(0, 5);\r
+ Assert.IsTrue(IC.eq(lst, 5));\r
+ lst.Insert(0, 7);\r
+ Assert.IsTrue(IC.eq(lst, 7, 5));\r
+ lst.Insert(1, 4);\r
+ Assert.IsTrue(IC.eq(lst, 7, 4, 5));\r
+ lst.Insert(3, 2);\r
+ Assert.IsTrue(IC.eq(lst, 7, 4, 5, 2));\r
+ }\r
+\r
+ [Test]\r
+ public void InsertDuplicate()\r
+ {\r
+ lst.Insert(0, 5);\r
+ Assert.IsTrue(IC.eq(lst, 5));\r
+ lst.Insert(0, 7);\r
+ Assert.IsTrue(IC.eq(lst, 7, 5));\r
+ lst.Insert(1, 5);\r
+ Assert.IsTrue(IC.eq(lst, 7, 5, 5));\r
+ }\r
+\r
+ [Test]\r
+ public void InsertAllDuplicate1()\r
+ {\r
+ lst.Insert(0, 3);\r
+ Assert.IsTrue(IC.eq(lst, 3));\r
+ lst.Insert(0, 7);\r
+ Assert.IsTrue(IC.eq(lst, 7, 3));\r
+ lst.InsertAll<int>(1, new int[] { 1, 2, 3, 4 });\r
+ Assert.IsTrue(IC.eq(lst, 7, 1, 2, 3, 4, 3));\r
+ Assert.IsTrue(lst.Check());\r
+ }\r
+ [Test]\r
+ public void InsertAllDuplicate2()\r
+ {\r
+ lst.Insert(0, 3);\r
+ Assert.IsTrue(IC.eq(lst, 3));\r
+ lst.Insert(0, 7);\r
+ Assert.IsTrue(IC.eq(lst, 7, 3));\r
+ lst.InsertAll<int>(1, new int[] { 5, 6, 5, 8 });\r
+ Assert.IsTrue(lst.Check());\r
+ Assert.IsTrue(IC.eq(lst, 7, 5, 6, 5, 8, 3));\r
+ }\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(IndexOutOfRangeException))]\r
+ public void BadInsertLow()\r
+ {\r
+ lst.Add(7);\r
+ lst.Insert(-1, 9);\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(IndexOutOfRangeException))]\r
+ public void BadInsertHi()\r
+ {\r
+ lst.Add(6);\r
+ lst.Insert(2, 11);\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void FIFO()\r
+ {\r
+ for (int i = 0; i < 7; i++)\r
+ lst.Add(2 * i);\r
+\r
+ Assert.IsTrue(lst.FIFO);\r
+ Assert.AreEqual(0, lst.Remove());\r
+ Assert.AreEqual(2, lst.Remove());\r
+ lst.FIFO = false;\r
+ Assert.AreEqual(12, lst.Remove());\r
+ Assert.AreEqual(10, lst.Remove());\r
+ lst.FIFO = true;\r
+ Assert.AreEqual(4, lst.Remove());\r
+ Assert.AreEqual(6, lst.Remove());\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void InsertFirstLast()\r
+ {\r
+ lst.InsertFirst(4);\r
+ lst.InsertLast(5);\r
+ lst.InsertFirst(14);\r
+ lst.InsertLast(15);\r
+ lst.InsertFirst(24);\r
+ lst.InsertLast(25);\r
+ lst.InsertFirst(34);\r
+ lst.InsertLast(55);\r
+ Assert.IsTrue(IC.eq(lst, 34, 24, 14, 4, 5, 15, 25, 55));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void InsertFirst()\r
+ {\r
+ lst.Add(2);\r
+ lst.Add(3);\r
+ lst.Add(2);\r
+ lst.Add(5);\r
+ lst.ViewOf(2).InsertFirst(7);\r
+ Assert.IsTrue(lst.Check());\r
+ Assert.IsTrue(IC.eq(lst, 7, 2, 3, 2, 5));\r
+ lst.ViewOf(3).InsertFirst(8);\r
+ Assert.IsTrue(lst.Check());\r
+ Assert.IsTrue(IC.eq(lst, 7, 2, 8, 3, 2, 5));\r
+ lst.ViewOf(5).InsertFirst(9);\r
+ Assert.IsTrue(lst.Check());\r
+ Assert.IsTrue(IC.eq(lst, 7, 2, 8, 3, 2, 9, 5));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void BadInsertFirst()\r
+ {\r
+ lst.Add(2);\r
+ lst.Add(3);\r
+ lst.Add(2);\r
+ lst.Add(5);\r
+ Assert.IsNull(lst.ViewOf(4));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void InsertAfter()\r
+ {\r
+ lst.Add(1);\r
+ lst.Add(2);\r
+ lst.Add(3);\r
+ lst.Add(2);\r
+ lst.Add(5);\r
+ lst.LastViewOf(2).InsertLast(7);\r
+ Assert.IsTrue(lst.Check());\r
+ Assert.IsTrue(IC.eq(lst, 1, 2, 3, 2, 7, 5));\r
+ lst.LastViewOf(1).InsertLast(8);\r
+ Assert.IsTrue(lst.Check());\r
+ Assert.IsTrue(IC.eq(lst, 1, 8, 2, 3, 2, 7, 5));\r
+ lst.LastViewOf(5).InsertLast(9);\r
+ Assert.IsTrue(lst.Check());\r
+ Assert.IsTrue(IC.eq(lst, 1, 8, 2, 3, 2, 7, 5, 9));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void BadInsertAfter()\r
+ {\r
+ lst.Add(2);\r
+ lst.Add(3);\r
+ lst.Add(2);\r
+ lst.Add(5);\r
+ Assert.IsNull(lst.ViewOf(4));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void InsertAll()\r
+ {\r
+ lst.Add(1);\r
+ lst.Add(2);\r
+ lst.Add(3);\r
+ lst.Add(4);\r
+\r
+ IList<int> lst2 = new LinkedList<int>();\r
+\r
+ lst2.Add(7); lst2.Add(8); lst2.Add(9);\r
+ lst.InsertAll(0, lst2);\r
+ Assert.IsTrue(lst.Check());\r
+ Assert.IsTrue(IC.eq(lst, 7, 8, 9, 1, 2, 3, 4));\r
+ lst.InsertAll(7, lst2);\r
+ Assert.IsTrue(lst.Check());\r
+ Assert.IsTrue(IC.eq(lst, 7, 8, 9, 1, 2, 3, 4, 7, 8, 9));\r
+ lst.InsertAll(5, lst2);\r
+ Assert.IsTrue(lst.Check());\r
+ Assert.IsTrue(IC.eq(lst, 7, 8, 9, 1, 2, 7, 8, 9, 3, 4, 7, 8, 9));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Map()\r
+ {\r
+ Fun<int, string> m = delegate(int i) { return "<<" + i + ">>"; };\r
+ IList<string> r = lst.Map(m);\r
+\r
+ Assert.IsTrue(r.Check());\r
+ Assert.IsTrue(r.IsEmpty);\r
+ lst.Add(1);\r
+ lst.Add(2);\r
+ lst.Add(3);\r
+ lst.Add(4);\r
+ r = lst.Map(m);\r
+ Assert.IsTrue(r.Check());\r
+ Assert.AreEqual(4, r.Count);\r
+ for (int i = 0; i < 4; i++)\r
+ Assert.AreEqual("<<" + (i + 1) + ">>", r[i]);\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(CollectionModifiedException))]\r
+ public void BadMapper()\r
+ {\r
+ lst.Add(1);\r
+ lst.Add(2);\r
+ lst.Add(3);\r
+ Fun<int, bool> m = delegate(int i) { if (i == 2) lst.Add(7); return true; };\r
+ lst.Map(m);\r
+ }\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(CollectionModifiedException))]\r
+ public void ModifyingFindAll()\r
+ {\r
+ lst.Add(1);\r
+ lst.Add(2);\r
+ lst.Add(3);\r
+ Fun<int, bool> m = delegate(int i) { if (i == 2) lst.Add(7); return true; };\r
+ lst.FindAll(m);\r
+ }\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(CollectionModifiedException))]\r
+ public void BadMapperView()\r
+ {\r
+ lst = lst.View(0, 0);\r
+ lst.Add(1);\r
+ lst.Add(2);\r
+ lst.Add(3);\r
+ Fun<int, bool> m = delegate(int i) { if (i == 2) lst.Add(7); return true; };\r
+ lst.Map(m);\r
+ }\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(CollectionModifiedException))]\r
+ public void ModifyingFindAllView()\r
+ {\r
+ lst = lst.View(0, 0);\r
+ lst.Add(1);\r
+ lst.Add(2);\r
+ lst.Add(3);\r
+ Fun<int, bool> m = delegate(int i) { if (i == 2) lst.Add(7); return true; };\r
+ lst.FindAll(m);\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(NoSuchItemException))]\r
+ public void BadRemove() { lst.Remove(); }\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(NoSuchItemException))]\r
+ public void BadRemoveFirst() { lst.RemoveFirst(); }\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(NoSuchItemException))]\r
+ public void BadRemoveLast() { lst.RemoveLast(); }\r
+\r
+\r
+ [Test]\r
+ public void RemoveFirstLast()\r
+ {\r
+ lst.Add(1);\r
+ lst.Add(2);\r
+ lst.Add(3);\r
+ lst.Add(4);\r
+ Assert.AreEqual(1, lst.RemoveFirst());\r
+ Assert.AreEqual(4, lst.RemoveLast());\r
+ Assert.AreEqual(2, lst.RemoveFirst());\r
+ Assert.AreEqual(3, lst.RemoveLast());\r
+ Assert.IsTrue(lst.IsEmpty);\r
+ }\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(NoSuchItemException))]\r
+ public void RemoveFirstEmpty()\r
+ {\r
+ lst.RemoveFirst();\r
+ }\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(NoSuchItemException))]\r
+ public void RemoveLastEmpty()\r
+ {\r
+ lst.RemoveLast();\r
+ }\r
+\r
+ [Test]\r
+ public void Reverse()\r
+ {\r
+ for (int i = 0; i < 10; i++)\r
+ lst.Add(i);\r
+\r
+ lst.Reverse();\r
+ Assert.IsTrue(lst.Check());\r
+ Assert.IsTrue(IC.eq(lst, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0));\r
+ lst.View(0, 3).Reverse();\r
+ Assert.IsTrue(lst.Check());\r
+ Assert.IsTrue(IC.eq(lst, 7, 8, 9, 6, 5, 4, 3, 2, 1, 0));\r
+ lst.View(7, 0).Reverse();\r
+ Assert.IsTrue(lst.Check());\r
+ Assert.IsTrue(IC.eq(lst, 7, 8, 9, 6, 5, 4, 3, 2, 1, 0));\r
+ lst.View(7, 3).Reverse();\r
+ Assert.IsTrue(lst.Check());\r
+ Assert.IsTrue(IC.eq(lst, 7, 8, 9, 6, 5, 4, 3, 0, 1, 2));\r
+ lst.View(5, 1).Reverse();\r
+ Assert.IsTrue(lst.Check());\r
+ Assert.IsTrue(IC.eq(lst, 7, 8, 9, 6, 5, 4, 3, 0, 1, 2));\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
+ public void BadReverse()\r
+ {\r
+ for (int i = 0; i < 10; i++)\r
+ lst.Add(i);\r
+\r
+ lst.View(8, 3).Reverse();\r
+ }\r
+ }\r
+\r
+\r
+\r
+ [TestFixture]\r
+ public class SortingTests\r
+ {\r
+ private IList<int> lst;\r
+\r
+\r
+ [SetUp]\r
+ public void Init() { lst = new LinkedList<int>(); }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose() { lst = null; }\r
+\r
+\r
+ [Test]\r
+ public void Sort()\r
+ {\r
+ lst.Add(5); lst.Add(6); lst.Add(5); lst.Add(7); lst.Add(3);\r
+ Assert.IsFalse(lst.IsSorted(new IC()));\r
+ lst.Sort(new IC());\r
+ Assert.IsTrue(lst.Check());\r
+ Assert.IsTrue(lst.IsSorted());\r
+ Assert.IsTrue(lst.IsSorted(new IC()));\r
+ Assert.IsTrue(IC.eq(lst, 3, 5, 5, 6, 7));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Stability()\r
+ {\r
+ IList<KeyValuePair<int, string>> lst2 = new LinkedList<KeyValuePair<int, string>>();\r
+ SCG.IComparer<KeyValuePair<int, string>> c = new KeyValuePairComparer<int, string>(new IC());\r
+\r
+ lst2.Add(new KeyValuePair<int, string>(5, "a"));\r
+ lst2.Add(new KeyValuePair<int, string>(5, "b"));\r
+ lst2.Add(new KeyValuePair<int, string>(6, "c"));\r
+ lst2.Add(new KeyValuePair<int, string>(4, "d"));\r
+ lst2.Add(new KeyValuePair<int, string>(3, "e"));\r
+ lst2.Add(new KeyValuePair<int, string>(4, "f"));\r
+ lst2.Add(new KeyValuePair<int, string>(5, "handle"));\r
+ Assert.IsFalse(lst2.IsSorted(c));\r
+ lst2.Sort(c);\r
+ Assert.IsTrue(lst2.IsSorted(c));\r
+\r
+ KeyValuePair<int, string> p = lst2.RemoveFirst();\r
+\r
+ Assert.AreEqual(3, p.Key);\r
+ Assert.AreEqual("e", p.Value);\r
+ p = lst2.RemoveFirst();\r
+ Assert.AreEqual(4, p.Key);\r
+ Assert.AreEqual("d", p.Value);\r
+ p = lst2.RemoveFirst();\r
+ Assert.AreEqual(4, p.Key);\r
+ Assert.AreEqual("f", p.Value);\r
+ p = lst2.RemoveFirst();\r
+ Assert.AreEqual(5, p.Key);\r
+ Assert.AreEqual("a", p.Value);\r
+ p = lst2.RemoveFirst();\r
+ Assert.AreEqual(5, p.Key);\r
+ Assert.AreEqual("b", p.Value);\r
+ p = lst2.RemoveFirst();\r
+ Assert.AreEqual(5, p.Key);\r
+ Assert.AreEqual("handle", p.Value);\r
+ p = lst2.RemoveFirst();\r
+ Assert.AreEqual(6, p.Key);\r
+ Assert.AreEqual("c", p.Value);\r
+ Assert.IsTrue(lst2.IsEmpty);\r
+ }\r
+ }\r
+ [TestFixture]\r
+ public class ShuffleTests\r
+ {\r
+ private IList<int> lst;\r
+\r
+\r
+ [SetUp]\r
+ public void Init() { lst = new LinkedList<int>(); }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose() { lst = null; }\r
+\r
+\r
+ [Test]\r
+ public void Shuffle()\r
+ {\r
+ lst.Add(5); lst.Add(6); lst.Add(5); lst.Add(7); lst.Add(3);\r
+ for (int i = 0; i < 100; i++)\r
+ {\r
+ lst.Shuffle(new C5Random(i + 1));\r
+ Assert.IsTrue(lst.Check(), "Check " + i);\r
+ int[] lst2 = lst.ToArray();\r
+ Sorting.IntroSort<int>(lst2);\r
+ Assert.IsTrue(IC.eq(lst2, 3, 5, 5, 6, 7), "Contents " + i);\r
}\r
- [TestFixture]\r
- public class Queue\r
+ }\r
+ }\r
+ }\r
+\r
+\r
+ namespace IStackQueue\r
+ {\r
+ [TestFixture]\r
+ public class Stack\r
+ {\r
+ private IStack<int> list;\r
+\r
+\r
+ [SetUp]\r
+ public void Init() { list = new LinkedList<int>(); }\r
+\r
+\r
+ [Test]\r
+ public void Normal()\r
+ {\r
+ list.Push(7);\r
+ list.Push(5);\r
+ list.Push(7);\r
+ list.Push(8);\r
+ list.Push(9);\r
+ Assert.AreEqual(9, list.Pop());\r
+ Assert.AreEqual(8, list.Pop());\r
+ Assert.AreEqual(7, list.Pop());\r
+ Assert.AreEqual(5, list.Pop());\r
+ Assert.AreEqual(7, list.Pop());\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(NoSuchItemException))]\r
+ public void PopEmpty()\r
+ {\r
+ list.Push(5);\r
+ Assert.AreEqual(5, list.Pop());\r
+ list.Pop();\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose() { list = null; }\r
+ }\r
+ [TestFixture]\r
+ public class Queue\r
+ {\r
+ private IQueue<int> list;\r
+\r
+\r
+ [SetUp]\r
+ public void Init() { list = new LinkedList<int>(); }\r
+\r
+\r
+ [Test]\r
+ public void Normal()\r
+ {\r
+ list.Enqueue(7);\r
+ list.Enqueue(5);\r
+ list.Enqueue(7);\r
+ list.Enqueue(8);\r
+ list.Enqueue(9);\r
+ Assert.AreEqual(7, list.Dequeue());\r
+ Assert.AreEqual(5, list.Dequeue());\r
+ Assert.AreEqual(7, list.Dequeue());\r
+ Assert.AreEqual(8, list.Dequeue());\r
+ Assert.AreEqual(9, list.Dequeue());\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(NoSuchItemException))]\r
+ public void DeQueueEmpty()\r
+ {\r
+ list.Enqueue(5);\r
+ Assert.AreEqual(5, list.Dequeue());\r
+ list.Dequeue();\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose() { list = null; }\r
+ }\r
+ }\r
+\r
+\r
+ namespace Range\r
+ {\r
+ [TestFixture]\r
+ public class Range\r
+ {\r
+ private IList<int> lst;\r
+\r
+\r
+ [SetUp]\r
+ public void Init() { lst = new LinkedList<int>(); }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose() { lst = null; }\r
+\r
+\r
+ [Test]\r
+ public void GetRange()\r
+ {\r
+ //Assert.IsTrue(IC.eq(lst[0, 0)));\r
+ for (int i = 0; i < 10; i++) lst.Add(i);\r
+\r
+ Assert.IsTrue(IC.eq(lst[0, 3], 0, 1, 2));\r
+ Assert.IsTrue(IC.eq(lst[3, 4], 3, 4, 5, 6));\r
+ Assert.IsTrue(IC.eq(lst[6, 4], 6, 7, 8, 9));\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(ArgumentOutOfRangeException))]\r
+ public void BadGetRange()\r
+ {\r
+ object foo = lst[0, 11];\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Backwards()\r
+ {\r
+ for (int i = 0; i < 10; i++) lst.Add(i);\r
+\r
+ Assert.IsTrue(IC.eq(lst.Backwards(), 9, 8, 7, 6, 5, 4, 3, 2, 1, 0));\r
+ Assert.IsTrue(IC.eq(lst[0, 4].Backwards(), 3, 2, 1, 0));\r
+ Assert.IsTrue(IC.eq(lst[3, 4].Backwards(), 6, 5, 4, 3));\r
+ Assert.IsTrue(IC.eq(lst[6, 4].Backwards(), 9, 8, 7, 6));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void DirectionAndCount()\r
+ {\r
+ for (int i = 0; i < 10; i++) lst.Add(i);\r
+\r
+ Assert.AreEqual(EnumerationDirection.Forwards, lst.Direction);\r
+ Assert.AreEqual(EnumerationDirection.Forwards, lst[3, 7].Direction);\r
+ Assert.AreEqual(EnumerationDirection.Backwards, lst[3, 7].Backwards().Direction);\r
+ Assert.AreEqual(EnumerationDirection.Backwards, lst.Backwards().Direction);\r
+ Assert.AreEqual(4, lst[3, 4].Count);\r
+ Assert.AreEqual(4, lst[3, 4].Backwards().Count);\r
+ Assert.AreEqual(10, lst.Backwards().Count);\r
+ }\r
+\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(CollectionModifiedException))]\r
+ public void MoveNextAfterUpdate()\r
+ {\r
+ for (int i = 0; i < 10; i++) lst.Add(i);\r
+\r
+ foreach (int i in lst)\r
{\r
- private IQueue<int> list;\r
+ lst.Add(45 + i);\r
+ }\r
+ }\r
+ }\r
+ }\r
\r
\r
- [SetUp]\r
- public void Init() { list = new LinkedList<int>(); }\r
\r
\r
- [Test]\r
- public void Normal()\r
- {\r
- list.EnQueue(7);\r
- list.EnQueue(5);\r
- list.EnQueue(7);\r
- list.EnQueue(8);\r
- list.EnQueue(9);\r
- Assert.AreEqual(7, list.DeQueue());\r
- Assert.AreEqual(5, list.DeQueue());\r
- Assert.AreEqual(7, list.DeQueue());\r
- Assert.AreEqual(8, list.DeQueue());\r
- Assert.AreEqual(9, list.DeQueue());\r
- }\r
+ namespace View\r
+ {\r
+ [TestFixture]\r
+ public class Simple\r
+ {\r
+ LinkedList<int> list, view;\r
+\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ list = new LinkedList<int>();\r
+ list.Add(0); list.Add(1); list.Add(2); list.Add(3);\r
+ view = (LinkedList<int>)list.View(1, 2);\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose()\r
+ {\r
+ list = view = null;\r
+ }\r
+\r
+\r
+ void check()\r
+ {\r
+ Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(view.Check());\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void InsertPointer()\r
+ {\r
+ IList<int> view2 = list.View(2, 0);\r
+ list.Insert(view2, 7);\r
+ check();\r
+ list.Insert(list, 8);\r
+ check();\r
+ view.Insert(view2, 9);\r
+ check();\r
+ view.Insert(list.View(3, 2), 10);\r
+ check();\r
+ view.Insert(list.ViewOf(0), 11);\r
+ check();\r
+ Assert.IsTrue(IC.eq(list, 0, 11, 1, 9, 7, 2, 10, 3, 8));\r
+ Assert.IsTrue(IC.eq(view, 11, 1, 9, 7, 2, 10));\r
+ }\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(IndexOutOfRangeException))]\r
+ public void InsertPointerBad1()\r
+ {\r
+ view.Insert(list.View(0, 0), 7);\r
+ }\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(IndexOutOfRangeException))]\r
+ public void InsertPointerBad2()\r
+ {\r
+ view.Insert(list, 7);\r
+ }\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(IncompatibleViewException))]\r
+ public void InsertPointerBad3()\r
+ {\r
+ list.Insert(new ArrayList<int>(), 7);\r
+ }\r
+\r
+ [Test]\r
+ [ExpectedException(typeof(IncompatibleViewException))]\r
+ public void InsertPointerBad4()\r
+ {\r
+ list.Insert(new ArrayList<int>().View(0, 0), 7);\r
+ }\r
+\r
+ [Test]\r
+ public void Span()\r
+ {\r
+ IList<int> span = list.View(1, 0).Span(list.View(2, 0));\r
+ Assert.IsTrue(span.Check());\r
+ Assert.AreEqual(1, span.Offset);\r
+ Assert.AreEqual(1, span.Count);\r
+ span = list.View(0, 2).Span(list.View(2, 2));\r
+ Assert.IsTrue(span.Check());\r
+ Assert.AreEqual(0, span.Offset);\r
+ Assert.AreEqual(4, span.Count);\r
+ span = list.View(3, 1).Span(list.View(1, 1));\r
+ Assert.IsNull(span);\r
+ }\r
+\r
+ [Test]\r
+ public void ViewOf()\r
+ {\r
+ for (int i = 0; i < 4; i++)\r
+ list.Add(i);\r
+ IList<int> v = view.ViewOf(2);\r
+ Assert.IsTrue(v.Check());\r
+ Assert.IsTrue(IC.eq(v, 2));\r
+ Assert.AreEqual(2, v.Offset);\r
+ v = list.ViewOf(2);\r
+ Assert.IsTrue(v.Check());\r
+ Assert.IsTrue(IC.eq(v, 2));\r
+ Assert.AreEqual(2, v.Offset);\r
+ v = list.LastViewOf(2);\r
+ Assert.IsTrue(v.Check());\r
+ Assert.IsTrue(IC.eq(v, 2));\r
+ Assert.AreEqual(6, v.Offset);\r
+ }\r
+\r
+ [Test]\r
+ public void BadViewOf()\r
+ {\r
+ Assert.IsNull(view.ViewOf(5));\r
+ Assert.IsNull(view.LastViewOf(5));\r
+ Assert.IsNull(view.ViewOf(3));\r
+ Assert.IsNull(view.LastViewOf(3));\r
+ Assert.IsNull(view.ViewOf(0));\r
+ Assert.IsNull(view.LastViewOf(0));\r
+ }\r
+\r
+ [Test]\r
+ public void ArrayStuff()\r
+ {\r
+ Assert.IsTrue(IC.eq(view.ToArray(), 1, 2));\r
+ int[] extarray = new int[5];\r
+ view.CopyTo(extarray, 2);\r
+ Assert.IsTrue(IC.eq(extarray, 0, 0, 1, 2, 0));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Add()\r
+ {\r
+ check();\r
+ Assert.IsTrue(IC.eq(list, 0, 1, 2, 3));\r
+ Assert.IsTrue(IC.eq(view, 1, 2));\r
+ view.InsertFirst(10);\r
+ check();\r
+ Assert.IsTrue(IC.eq(list, 0, 10, 1, 2, 3));\r
+ Assert.IsTrue(IC.eq(view, 10, 1, 2));\r
+ view.Clear();\r
+ Assert.IsFalse(view.IsReadOnly);\r
+ Assert.IsTrue(view.AllowsDuplicates);\r
+ Assert.IsTrue(view.IsEmpty);\r
+ check();\r
+ Assert.IsTrue(IC.eq(list, 0, 3));\r
+ Assert.IsTrue(IC.eq(view));\r
+ view.Add(8);\r
+ Assert.IsFalse(view.IsEmpty);\r
+ Assert.IsTrue(view.AllowsDuplicates);\r
+ Assert.IsFalse(view.IsReadOnly);\r
+ check();\r
+ Assert.IsTrue(IC.eq(list, 0, 8, 3));\r
+ Assert.IsTrue(IC.eq(view, 8));\r
+ view.Add(12);\r
+ check();\r
+ Assert.IsTrue(IC.eq(list, 0, 8, 12, 3));\r
+ Assert.IsTrue(IC.eq(view, 8, 12));\r
+ view./*ViewOf(12).*/InsertLast(15);\r
+ check();\r
+ Assert.IsTrue(IC.eq(list, 0, 8, 12, 15, 3));\r
+ Assert.IsTrue(IC.eq(view, 8, 12, 15));\r
+ view.ViewOf(12).InsertFirst(18);\r
+ check();\r
+ Assert.IsTrue(IC.eq(list, 0, 8, 18, 12, 15, 3));\r
+ Assert.IsTrue(IC.eq(view, 8, 18, 12, 15));\r
+\r
+ LinkedList<int> lst2 = new LinkedList<int>();\r
+\r
+ lst2.Add(90); lst2.Add(92);\r
+ view.AddAll(lst2);\r
+ check();\r
+ Assert.IsTrue(IC.eq(list, 0, 8, 18, 12, 15, 90, 92, 3));\r
+ Assert.IsTrue(IC.eq(view, 8, 18, 12, 15, 90, 92));\r
+ view.InsertLast(66);\r
+ check();\r
+ Assert.IsTrue(IC.eq(list, 0, 8, 18, 12, 15, 90, 92, 66, 3));\r
+ Assert.IsTrue(IC.eq(view, 8, 18, 12, 15, 90, 92, 66));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Bxxx()\r
+ {\r
+ Assert.IsTrue(IC.eq(view.Backwards(), 2, 1));\r
+ Assert.AreSame(list, view.Underlying);\r
+ Assert.IsNull(list.Underlying);\r
+ Assert.AreEqual(EnumerationDirection.Forwards, view.Direction);\r
+ Assert.AreEqual(EnumerationDirection.Backwards, view.Backwards().Direction);\r
+ Assert.AreEqual(0, list.Offset);\r
+ Assert.AreEqual(1, view.Offset);\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Contains()\r
+ {\r
+ Assert.IsTrue(view.Contains(1));\r
+ Assert.IsFalse(view.Contains(0));\r
+\r
+ LinkedList<int> lst2 = new LinkedList<int>();\r
+\r
+ lst2.Add(2);\r
+ Assert.IsTrue(view.ContainsAll(lst2));\r
+ lst2.Add(3);\r
+ Assert.IsFalse(view.ContainsAll(lst2));\r
+ Assert.AreEqual(Speed.Linear, view.ContainsSpeed);\r
+ Assert.AreEqual(2, view.Count);\r
+ view.Add(1);\r
+ Assert.AreEqual(1, view.ContainsCount(2));\r
+ Assert.AreEqual(2, view.ContainsCount(1));\r
+ Assert.AreEqual(3, view.Count);\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void CreateView()\r
+ {\r
+ LinkedList<int> view2 = (LinkedList<int>)view.View(1, 0);\r
+\r
+ Assert.AreSame(list, view2.Underlying);\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void FIFO()\r
+ {\r
+ Assert.IsTrue(view.FIFO);\r
+ view.Add(23); view.Add(24); view.Add(25);\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 1, 2, 23, 24, 25));\r
+ Assert.AreEqual(1, view.Remove());\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 2, 23, 24, 25));\r
+ view.FIFO = false;\r
+ Assert.IsFalse(view.FIFO);\r
+ Assert.AreEqual(25, view.Remove());\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 2, 23, 24));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void MapEtc()\r
+ {\r
+ LinkedList<double> dbl = (LinkedList<double>)view.Map(new Fun<int, double>(delegate(int i) { return i / 10.0; }));\r
+\r
+ Assert.IsTrue(dbl.Check());\r
+ Assert.AreEqual(0.1, dbl[0]);\r
+ Assert.AreEqual(0.2, dbl[1]);\r
+ for (int i = 0; i < 10; i++) view.Add(i);\r
+\r
+ list = (LinkedList<int>)view.FindAll(new Fun<int, bool>(delegate(int i) { return i % 4 == 1; }));\r
+ Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(IC.eq(list, 1, 1, 5, 9));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void FL()\r
+ {\r
+ Assert.AreEqual(1, view.First);\r
+ Assert.AreEqual(2, view.Last);\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Indexing()\r
+ {\r
+ list.Clear();\r
+ for (int i = 0; i < 20; i++) list.Add(i);\r
+\r
+ view = (LinkedList<int>)list.View(5, 7);\r
+ for (int i = 0; i < 7; i++) Assert.AreEqual(i + 5, view[i]);\r
+\r
+ for (int i = 0; i < 7; i++) Assert.AreEqual(i, view.IndexOf(i + 5));\r
+\r
+ for (int i = 0; i < 7; i++) Assert.AreEqual(i, view.LastIndexOf(i + 5));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void INsert()\r
+ {\r
+ view.Insert(0, 34);\r
+ view.Insert(1, 35);\r
+ view.Insert(4, 36);\r
+ Assert.IsTrue(view.Check());\r
+ Assert.IsTrue(IC.eq(view, 34, 35, 1, 2, 36));\r
+\r
+ IList<int> list2 = new LinkedList<int>();\r
+\r
+ list2.AddAll(view);\r
+ view.InsertAll(3, list2);\r
+ Assert.IsTrue(view.Check());\r
+ Assert.IsTrue(IC.eq(view, 34, 35, 1, 34, 35, 1, 2, 36, 2, 36));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Sort()\r
+ {\r
+ view.Add(45); view.Add(47); view.Add(46); view.Add(48);\r
+ Assert.IsFalse(view.IsSorted(new IC()));\r
+ view.Sort(new IC());\r
+ check();\r
+ Assert.IsTrue(IC.eq(list, 0, 1, 2, 45, 46, 47, 48, 3));\r
+ Assert.IsTrue(IC.eq(view, 1, 2, 45, 46, 47, 48));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Remove()\r
+ {\r
+ view.FIFO = false;\r
+ view.Add(1); view.Add(5); view.Add(3); view.Add(1); view.Add(3); view.Add(0);\r
+ Assert.IsTrue(IC.eq(view, 1, 2, 1, 5, 3, 1, 3, 0));\r
+ Assert.IsTrue(view.Remove(1));\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 1, 2, 1, 5, 3, 3, 0));\r
+ Assert.IsTrue(view.Remove(1));\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 1, 2, 5, 3, 3, 0));\r
+ Assert.IsTrue(view.Remove(0));\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 1, 2, 5, 3, 3));\r
+ view.RemoveAllCopies(3);\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 1, 2, 5));\r
+ Assert.IsTrue(IC.eq(list, 0, 1, 2, 5, 3));\r
+ view.Add(1); view.Add(5); view.Add(3); view.Add(1); view.Add(3); view.Add(0);\r
+ Assert.IsTrue(IC.eq(view, 1, 2, 5, 1, 5, 3, 1, 3, 0));\r
+\r
+ view.FIFO = true;\r
+ view.Clear(); view.Add(1); view.Add(2);\r
+\r
+ view.Add(1); view.Add(5); view.Add(3); view.Add(1); view.Add(3); view.Add(0);\r
+ Assert.IsTrue(IC.eq(view, 1, 2, 1, 5, 3, 1, 3, 0));\r
+ Assert.IsTrue(view.Remove(1));\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 2, 1, 5, 3, 1, 3, 0));\r
+ Assert.IsTrue(view.Remove(1));\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 2, 5, 3, 1, 3, 0));\r
+ Assert.IsTrue(view.Remove(0));\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 2, 5, 3, 1, 3));\r
+ view.RemoveAllCopies(3);\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 2, 5, 1));\r
+ Assert.IsTrue(IC.eq(list, 0, 2, 5, 1, 3));\r
+ view.Add(1); view.Add(5); view.Add(3); view.Add(1); view.Add(3); view.Add(0);\r
+ Assert.IsTrue(IC.eq(view, 2, 5, 1, 1, 5, 3, 1, 3, 0));\r
+\r
+ LinkedList<int> l2 = new LinkedList<int>();\r
+\r
+ l2.Add(1); l2.Add(2); l2.Add(2); l2.Add(3); l2.Add(1);\r
+ view.RemoveAll(l2);\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 5, 5, 1, 3, 0));\r
+ view.RetainAll(l2);\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 1, 3));\r
+ view.Add(2); view.Add(4); view.Add(5);\r
+ Assert.AreEqual(1, view.RemoveAt(0));\r
+ Assert.AreEqual(5, view.RemoveAt(3));\r
+ Assert.AreEqual(2, view.RemoveAt(1));\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 3, 4));\r
+ view.Add(8);\r
+ Assert.AreEqual(3, view.RemoveFirst());\r
+ Assert.AreEqual(8, view.RemoveLast());\r
+ view.Add(2); view.Add(5); view.Add(3); view.Add(1);\r
+ view.RemoveInterval(1, 2);\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 4, 3, 1));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Reverse()\r
+ {\r
+ view.Clear();\r
+ for (int i = 0; i < 10; i++) view.Add(10 + i);\r
+\r
+ view.View(3, 4).Reverse();\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 10, 11, 12, 16, 15, 14, 13, 17, 18, 19));\r
+ view.Reverse();\r
+ Assert.IsTrue(IC.eq(view, 19, 18, 17, 13, 14, 15, 16, 12, 11, 10));\r
+ Assert.IsTrue(IC.eq(list, 0, 19, 18, 17, 13, 14, 15, 16, 12, 11, 10, 3));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Slide()\r
+ {\r
+ view.Slide(1);\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 2, 3));\r
+ view.Slide(-2);\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 0, 1));\r
+ view.Slide(0, 3);\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 0, 1, 2));\r
+ view.Slide(2, 1);\r
+ check();\r
+ Assert.IsTrue(IC.eq(view, 2));\r
+ Assert.AreEqual(view, view.Slide(-1, 0));\r
+ check();\r
+ Assert.IsTrue(IC.eq(view));\r
+ view.Add(28);\r
+ Assert.IsTrue(IC.eq(list, 0, 28, 1, 2, 3));\r
+ }\r
+ [Test]\r
+ public void Iterate()\r
+ {\r
+ list.Clear();\r
+ view = null;\r
+ foreach (int i in new int[] { 2, 4, 8, 13, 6, 1, 2, 7 }) list.Add(i);\r
+\r
+ view = (LinkedList<int>)list.View(list.Count - 2, 2);\r
+ while (true)\r
+ {\r
+ //Console.WriteLine("View: {0}: {1} --> {2}", view.Count, view.First, view.Last);\r
+ if ((view.Last - view.First) % 2 == 1)\r
+ view.Insert(1, 666);\r
+ check();\r
+ if (view.Offset == 0)\r
+ break;\r
+ else\r
+ view.Slide(-1, 2);\r
+ }\r
+ //foreach (int cell in list) Console.Write(" " + cell);\r
+ //Assert.IsTrue(list.Check());\r
+ Assert.IsTrue(IC.eq(list, 2, 4, 8, 666, 13, 6, 1, 666, 2, 666, 7));\r
+ }\r
\r
\r
- [Test]\r
- [ExpectedException(typeof(InvalidOperationException))]\r
- public void DeQueueEmpty()\r
+ [Test]\r
+ public void SyncRoot()\r
+ {\r
+ Assert.AreSame(view.SyncRoot, list.SyncRoot);\r
+ }\r
+ }\r
+\r
+ [TestFixture]\r
+ public class MulipleViews\r
+ {\r
+ IList<int> list;\r
+ IList<int>[][] views;\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ list = new LinkedList<int>();\r
+ for (int i = 0; i < 6; i++)\r
+ list.Add(i);\r
+ views = new IList<int>[7][];\r
+ for (int i = 0; i < 7; i++)\r
+ {\r
+ views[i] = new IList<int>[7 - i];\r
+ for (int j = 0; j < 7 - i; j++)\r
+ views[i][j] = list.View(i, j);\r
+ }\r
+ }\r
+ [TearDown]\r
+ public void Dispose()\r
+ {\r
+ list = null;\r
+ views = null;\r
+ }\r
+ [Test]\r
+ public void Insert()\r
+ {\r
+ Assert.IsTrue(list.Check(), "list check before insert");\r
+ list.Insert(3, 777);\r
+ Assert.IsTrue(list.Check(), "list check after insert");\r
+ for (int i = 0; i < 7; i++)\r
+ for (int j = 0; j < 7 - i; j++)\r
+ {\r
+ Assert.AreEqual(i < 3 || (i == 3 && j == 0) ? i : i + 1, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
+ Assert.AreEqual(i < 3 && i + j > 3 ? j + 1 : j, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
+ }\r
+ }\r
+ [Test]\r
+ public void RemoveAt()\r
+ {\r
+ Assert.IsTrue(list.Check(), "list check before remove");\r
+ list.RemoveAt(3);\r
+ Assert.IsTrue(list.Check(), "list check after remove");\r
+ for (int i = 0; i < 7; i++)\r
+ for (int j = 0; j < 7 - i; j++)\r
+ {\r
+ Assert.AreEqual(i <= 3 ? i : i - 1, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
+ Assert.AreEqual(i <= 3 && i + j > 3 ? j - 1 : j, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
+ }\r
+ }\r
+\r
+ [Test]\r
+ public void RemoveInterval()\r
+ {\r
+ Assert.IsTrue(list.Check(), "list check before remove");\r
+ list.RemoveInterval(3, 2);\r
+ Assert.IsTrue(list.Check(), "list check after remove");\r
+ for (int i = 0; i < 7; i++)\r
+ for (int j = 0; j < 7 - i; j++)\r
+ {\r
+ Assert.AreEqual(i <= 3 ? i : i <= 5 ? 3 : i - 2, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
+ Assert.AreEqual(j == 0 ? 0 : i <= 3 && i + j > 4 ? j - 2 : i > 4 || i + j <= 3 ? j : j - 1, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
+ }\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void InsertAtEnd()\r
+ {\r
+ Assert.IsTrue(list.Check(), "list check before insert");\r
+ list.InsertLast(777);\r
+ Assert.IsTrue(list.Check(), "list check after insert");\r
+ for (int i = 0; i < 7; i++)\r
+ for (int j = 0; j < 7 - i; j++)\r
+ {\r
+ Assert.AreEqual(i, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
+ Assert.AreEqual(j, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
+ }\r
+ }\r
+ [Test]\r
+ public void RemoveAtEnd()\r
+ {\r
+ Assert.IsTrue(list.Check(), "list check before remove");\r
+ list.RemoveAt(5);\r
+ Assert.IsTrue(list.Check(), "list check after remove");\r
+ for (int i = 0; i < 7; i++)\r
+ for (int j = 0; j < 7 - i; j++)\r
+ {\r
+ Assert.AreEqual(i <= 5 ? i : i - 1, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
+ Assert.AreEqual(i <= 5 && i + j > 5 ? j - 1 : j, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
+ }\r
+ }\r
+ [Test]\r
+ public void InsertAtStart()\r
+ {\r
+ Assert.IsTrue(list.Check(), "list check before insert");\r
+ list.Insert(0, 777);\r
+ Assert.IsTrue(list.Check(), "list check after insert");\r
+ for (int i = 0; i < 7; i++)\r
+ for (int j = 0; j < 7 - i; j++)\r
+ {\r
+ Assert.AreEqual(i == 0 && j == 0 ? 0 : i + 1, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
+ Assert.AreEqual(j, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
+ }\r
+ }\r
+ [Test]\r
+ public void RemoveAtStart()\r
+ {\r
+ Assert.IsTrue(list.Check(), "list check before remove");\r
+ list.RemoveAt(0);\r
+ Assert.IsTrue(list.Check(), "list check after remove");\r
+ for (int i = 0; i < 7; i++)\r
+ for (int j = 0; j < 7 - i; j++)\r
+ {\r
+ Assert.AreEqual(i == 0 ? i : i - 1, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
+ Assert.AreEqual(i == 0 && j > 0 ? j - 1 : j, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
+ }\r
+ }\r
+ [Test]\r
+ public void Clear()\r
+ {\r
+ Assert.IsTrue(list.Check(), "list check before clear");\r
+ views[2][3].Clear();\r
+ Assert.IsTrue(list.Check(), "list check after clear");\r
+ for (int i = 0; i < 7; i++)\r
+ for (int j = 0; j < 7 - i; j++)\r
+ {\r
+ Assert.AreEqual(i < 2 ? i : i < 6 ? 2 : i - 3, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
+ Assert.AreEqual(s(i, j), views[i][j].Count, "view[" + i + "][" + j + "] count");\r
+ }\r
+ }\r
+\r
+ private int s(int i, int j)\r
+ {\r
+ if (j == 0) return 0;\r
+ int k = i + j - 1; //end\r
+ if (i > 4 || k <= 1) return j;\r
+ if (i >= 2) return k > 4 ? k - 4 : 0;\r
+ if (i <= 2) return k >= 4 ? j - 3 : 2 - i;\r
+ return -1;\r
+ }\r
+ [Test]\r
+ public void InsertAll()\r
+ {\r
+ LinkedList<int> list2 = new LinkedList<int>();\r
+ for (int i = 0; i < 5; i++) { list2.Add(100 + i); }\r
+ Assert.IsTrue(list.Check(), "list check before insertAll");\r
+ list.InsertAll(3, list2);\r
+ Assert.IsTrue(list.Check(), "list check after insertAll");\r
+ for (int i = 0; i < 7; i++)\r
+ for (int j = 0; j < 7 - i; j++)\r
+ {\r
+ Assert.AreEqual(i < 3 || (i == 3 && j == 0) ? i : i + 5, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
+ Assert.AreEqual(i < 3 && i + j > 3 ? j + 5 : j, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
+ }\r
+ }\r
+\r
+ [Test]\r
+ public void AddAll()\r
+ {\r
+ LinkedList<int> list2 = new LinkedList<int>();\r
+ for (int i = 0; i < 5; i++) { list2.Add(100 + i); }\r
+ Assert.IsTrue(list.Check(), "list check before AddAll");\r
+ list.View(1, 2).AddAll(list2);\r
+ Assert.IsTrue(list.Check(), "list check after AddAll");\r
+ for (int i = 0; i < 7; i++)\r
+ for (int j = 0; j < 7 - i; j++)\r
+ {\r
+ Assert.AreEqual(i < 3 || (i == 3 && j == 0) ? i : i + 5, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
+ Assert.AreEqual(i < 3 && i + j > 3 ? j + 5 : j, views[i][j].Count, "view[" + i + "][" + j + "] count");\r
+ }\r
+ }\r
+\r
+ [Test]\r
+ public void RemoveAll1()\r
+ {\r
+ LinkedList<int> list2 = new LinkedList<int>();\r
+ list2.Add(1); list2.Add(3); list2.Add(4);\r
+\r
+ for (int i = 0; i < 7; i++)\r
+ {\r
+ for (int j = 0; j < 7 - i; j++)\r
+ {\r
+ list = new LinkedList<int>();\r
+ for (int k = 0; k < 6; k++) list.Add(k);\r
+ LinkedList<int> v = (LinkedList<int>)list.View(i, j);\r
+ list.RemoveAll(list2);\r
+ Assert.IsTrue(list.Check(), "list check after RemoveAll, i=" + i + ", j=" + j);\r
+ }\r
+ }\r
+ }\r
+ [Test]\r
+ public void RemoveAll2()\r
+ {\r
+ LinkedList<int> list2 = new LinkedList<int>();\r
+ list2.Add(1); list2.Add(3); list2.Add(4);\r
+ Assert.IsTrue(list.Check(), "list check before RemoveAll");\r
+ list.RemoveAll(list2);\r
+\r
+ Assert.AreEqual(0, views[0][0].Offset, "view [0][0] offset");\r
+ Assert.AreEqual(0, views[0][1].Offset, "view [0][1] offset");\r
+ Assert.AreEqual(0, views[0][2].Offset, "view [0][2] offset");\r
+ Assert.AreEqual(0, views[0][3].Offset, "view [0][3] offset");\r
+ Assert.AreEqual(0, views[0][4].Offset, "view [0][4] offset");\r
+ Assert.AreEqual(0, views[0][5].Offset, "view [0][5] offset");\r
+ Assert.AreEqual(0, views[0][6].Offset, "view [0][6] offset");\r
+ Assert.AreEqual(1, views[1][0].Offset, "view [1][0] offset");\r
+ Assert.AreEqual(1, views[1][1].Offset, "view [1][1] offset");\r
+ Assert.AreEqual(1, views[1][2].Offset, "view [1][2] offset");\r
+ Assert.AreEqual(1, views[1][3].Offset, "view [1][3] offset");\r
+ Assert.AreEqual(1, views[1][4].Offset, "view [1][4] offset");\r
+ Assert.AreEqual(1, views[1][5].Offset, "view [1][5] offset");\r
+ Assert.AreEqual(1, views[2][0].Offset, "view [2][0] offset");\r
+ Assert.AreEqual(1, views[2][1].Offset, "view [2][1] offset");\r
+ Assert.AreEqual(1, views[2][2].Offset, "view [2][2] offset");\r
+ Assert.AreEqual(1, views[2][3].Offset, "view [2][3] offset");\r
+ Assert.AreEqual(1, views[2][4].Offset, "view [2][4] offset");\r
+ Assert.AreEqual(2, views[3][0].Offset, "view [3][0] offset");\r
+ Assert.AreEqual(2, views[3][1].Offset, "view [3][1] offset");\r
+ Assert.AreEqual(2, views[3][2].Offset, "view [3][2] offset");\r
+ Assert.AreEqual(2, views[3][3].Offset, "view [3][3] offset");\r
+ Assert.AreEqual(2, views[4][0].Offset, "view [4][0] offset");\r
+ Assert.AreEqual(2, views[4][1].Offset, "view [4][1] offset");\r
+ Assert.AreEqual(2, views[4][2].Offset, "view [4][2] offset");\r
+ Assert.AreEqual(2, views[5][0].Offset, "view [5][0] offset");\r
+ Assert.AreEqual(2, views[5][1].Offset, "view [5][1] offset");\r
+ Assert.AreEqual(3, views[6][0].Offset, "view [6][0] offset");\r
+\r
+ Assert.AreEqual(0, views[0][0].Count, "view [0][0] count");\r
+ Assert.AreEqual(1, views[0][1].Count, "view [0][1] count");\r
+ Assert.AreEqual(1, views[0][2].Count, "view [0][2] count");\r
+ Assert.AreEqual(2, views[0][3].Count, "view [0][3] count");\r
+ Assert.AreEqual(2, views[0][4].Count, "view [0][4] count");\r
+ Assert.AreEqual(2, views[0][5].Count, "view [0][5] count");\r
+ Assert.AreEqual(3, views[0][6].Count, "view [0][6] count");\r
+ Assert.AreEqual(0, views[1][0].Count, "view [1][0] count");\r
+ Assert.AreEqual(0, views[1][1].Count, "view [1][1] count");\r
+ Assert.AreEqual(1, views[1][2].Count, "view [1][2] count");\r
+ Assert.AreEqual(1, views[1][3].Count, "view [1][3] count");\r
+ Assert.AreEqual(1, views[1][4].Count, "view [1][4] count");\r
+ Assert.AreEqual(2, views[1][5].Count, "view [1][5] count");\r
+ Assert.AreEqual(0, views[2][0].Count, "view [2][0] count");\r
+ Assert.AreEqual(1, views[2][1].Count, "view [2][1] count");\r
+ Assert.AreEqual(1, views[2][2].Count, "view [2][2] count");\r
+ Assert.AreEqual(1, views[2][3].Count, "view [2][3] count");\r
+ Assert.AreEqual(2, views[2][4].Count, "view [2][4] count");\r
+ Assert.AreEqual(0, views[3][0].Count, "view [3][0] count");\r
+ Assert.AreEqual(0, views[3][1].Count, "view [3][1] count");\r
+ Assert.AreEqual(0, views[3][2].Count, "view [3][2] count");\r
+ Assert.AreEqual(1, views[3][3].Count, "view [3][3] count");\r
+ Assert.AreEqual(0, views[4][0].Count, "view [4][0] count");\r
+ Assert.AreEqual(0, views[4][1].Count, "view [4][1] count");\r
+ Assert.AreEqual(1, views[4][2].Count, "view [4][2] count");\r
+ Assert.AreEqual(0, views[5][0].Count, "view [5][0] count");\r
+ Assert.AreEqual(1, views[5][1].Count, "view [5][1] count");\r
+ Assert.AreEqual(0, views[6][0].Count, "view [6][0] count");\r
+\r
+ Assert.IsTrue(list.Check(), "list check after RemoveAll");\r
+ }\r
+\r
+ [Test]\r
+ public void RetainAll()\r
+ {\r
+ LinkedList<int> list2 = new LinkedList<int>();\r
+ list2.Add(2); list2.Add(4); list2.Add(5);\r
+ Assert.IsTrue(list.Check(), "list check before RetainAll");\r
+ list.RetainAll(list2);\r
+ Assert.AreEqual(0, views[0][0].Offset, "view [0][0] offset");\r
+ Assert.AreEqual(0, views[0][1].Offset, "view [0][1] offset");\r
+ Assert.AreEqual(0, views[0][2].Offset, "view [0][2] offset");\r
+ Assert.AreEqual(0, views[0][3].Offset, "view [0][3] offset");\r
+ Assert.AreEqual(0, views[0][4].Offset, "view [0][4] offset");\r
+ Assert.AreEqual(0, views[0][5].Offset, "view [0][5] offset");\r
+ Assert.AreEqual(0, views[0][6].Offset, "view [0][6] offset");\r
+ Assert.AreEqual(0, views[1][0].Offset, "view [1][0] offset");\r
+ Assert.AreEqual(0, views[1][1].Offset, "view [1][1] offset");\r
+ Assert.AreEqual(0, views[1][2].Offset, "view [1][2] offset");\r
+ Assert.AreEqual(0, views[1][3].Offset, "view [1][3] offset");\r
+ Assert.AreEqual(0, views[1][4].Offset, "view [1][4] offset");\r
+ Assert.AreEqual(0, views[1][5].Offset, "view [1][5] offset");\r
+ Assert.AreEqual(0, views[2][0].Offset, "view [2][0] offset");\r
+ Assert.AreEqual(0, views[2][1].Offset, "view [2][1] offset");\r
+ Assert.AreEqual(0, views[2][2].Offset, "view [2][2] offset");\r
+ Assert.AreEqual(0, views[2][3].Offset, "view [2][3] offset");\r
+ Assert.AreEqual(0, views[2][4].Offset, "view [2][4] offset");\r
+ Assert.AreEqual(1, views[3][0].Offset, "view [3][0] offset");\r
+ Assert.AreEqual(1, views[3][1].Offset, "view [3][1] offset");\r
+ Assert.AreEqual(1, views[3][2].Offset, "view [3][2] offset");\r
+ Assert.AreEqual(1, views[3][3].Offset, "view [3][3] offset");\r
+ Assert.AreEqual(1, views[4][0].Offset, "view [4][0] offset");\r
+ Assert.AreEqual(1, views[4][1].Offset, "view [4][1] offset");\r
+ Assert.AreEqual(1, views[4][2].Offset, "view [4][2] offset");\r
+ Assert.AreEqual(2, views[5][0].Offset, "view [5][0] offset");\r
+ Assert.AreEqual(2, views[5][1].Offset, "view [5][1] offset");\r
+ Assert.AreEqual(3, views[6][0].Offset, "view [6][0] offset");\r
+\r
+ Assert.AreEqual(0, views[0][0].Count, "view [0][0] count");\r
+ Assert.AreEqual(0, views[0][1].Count, "view [0][1] count");\r
+ Assert.AreEqual(0, views[0][2].Count, "view [0][2] count");\r
+ Assert.AreEqual(1, views[0][3].Count, "view [0][3] count");\r
+ Assert.AreEqual(1, views[0][4].Count, "view [0][4] count");\r
+ Assert.AreEqual(2, views[0][5].Count, "view [0][5] count");\r
+ Assert.AreEqual(3, views[0][6].Count, "view [0][6] count");\r
+ Assert.AreEqual(0, views[1][0].Count, "view [1][0] count");\r
+ Assert.AreEqual(0, views[1][1].Count, "view [1][1] count");\r
+ Assert.AreEqual(1, views[1][2].Count, "view [1][2] count");\r
+ Assert.AreEqual(1, views[1][3].Count, "view [1][3] count");\r
+ Assert.AreEqual(2, views[1][4].Count, "view [1][4] count");\r
+ Assert.AreEqual(3, views[1][5].Count, "view [1][5] count");\r
+ Assert.AreEqual(0, views[2][0].Count, "view [2][0] count");\r
+ Assert.AreEqual(1, views[2][1].Count, "view [2][1] count");\r
+ Assert.AreEqual(1, views[2][2].Count, "view [2][2] count");\r
+ Assert.AreEqual(2, views[2][3].Count, "view [2][3] count");\r
+ Assert.AreEqual(3, views[2][4].Count, "view [2][4] count");\r
+ Assert.AreEqual(0, views[3][0].Count, "view [3][0] count");\r
+ Assert.AreEqual(0, views[3][1].Count, "view [3][1] count");\r
+ Assert.AreEqual(1, views[3][2].Count, "view [3][2] count");\r
+ Assert.AreEqual(2, views[3][3].Count, "view [3][3] count");\r
+ Assert.AreEqual(0, views[4][0].Count, "view [4][0] count");\r
+ Assert.AreEqual(1, views[4][1].Count, "view [4][1] count");\r
+ Assert.AreEqual(2, views[4][2].Count, "view [4][2] count");\r
+ Assert.AreEqual(0, views[5][0].Count, "view [5][0] count");\r
+ Assert.AreEqual(1, views[5][1].Count, "view [5][1] count");\r
+ Assert.AreEqual(0, views[6][0].Count, "view [6][0] count");\r
+\r
+\r
+ Assert.IsTrue(list.Check(), "list check after RetainAll");\r
+ }\r
+\r
+ [Test]\r
+ public void RemoveAllCopies()\r
+ {\r
+ LinkedList<int> list2 = new LinkedList<int>();\r
+ list2.Add(0); list2.Add(2); list2.Add(2); list2.Add(2); list2.Add(5); list2.Add(2); list2.Add(1);\r
+ for (int i = 0; i < 7; i++)\r
+ {\r
+ for (int j = 0; j < 7 - i; j++)\r
+ {\r
+ list = new LinkedList<int>();\r
+ list.AddAll(list2);\r
+ LinkedList<int> v = (LinkedList<int>)list.View(i, j);\r
+ list.RemoveAllCopies(2);\r
+ Assert.AreEqual(i == 0 ? 0 : i <= 4 ? 1 : i <= 6 ? 2 : 3, v.Offset, "v.Offset, i=" + i + ", j=" + j);\r
+ Assert.AreEqual((i == 0 && j > 0 ? 1 : 0) + (i <= 4 && i + j > 4 ? 1 : 0) + (i <= 6 && i + j > 6 ? 1 : 0), v.Count, "v.Count, i=" + i + ", j=" + j);\r
+ Assert.IsTrue(list.Check(), "list check after RemoveAllCopies, i=" + i + ", j=" + j);\r
+ }\r
+ }\r
+ }\r
+\r
+ private void checkDisposed(bool reverse, int start, int count)\r
+ {\r
+ int k = 0;\r
+ for (int i = 0; i < 7; i++)\r
+ for (int j = 0; j < 7 - i; j++)\r
+ {\r
+ if (i + j <= start || i >= start + count || (i <= start && i + j >= start + count) || (reverse && start <= i && start + count >= i + j))\r
{\r
- list.EnQueue(5);\r
- Assert.AreEqual(5, list.DeQueue());\r
- list.DeQueue();\r
+ try\r
+ {\r
+ k = views[i][j].Count;\r
+ }\r
+ catch (ViewDisposedException)\r
+ {\r
+ Assert.Fail("view[" + i + "][" + j + "] threw");\r
+ }\r
+ Assert.AreEqual(j, views[i][j].Count, "view[" + i + "][" + j + "] size");\r
+ if (reverse && ((j > 0 && start <= i && start + count >= i + j) || (j == 0 && start < i && start + count > i)))\r
+ Assert.AreEqual(start + (start + count - i - j), views[i][j].Offset, "view[" + i + "][" + j + "] offset (mirrored)");\r
+ else\r
+ Assert.AreEqual(i, views[i][j].Offset, "view[" + i + "][" + j + "] offset");\r
}\r
+ else\r
+ {\r
+ try\r
+ {\r
+ k = views[i][j].Count;\r
+ Assert.Fail("view[" + i + "][" + j + "] no throw");\r
+ }\r
+ catch (ViewDisposedException) { }\r
+ }\r
+ }\r
+ }\r
+\r
+ [Test]\r
+ public void Reverse()\r
+ {\r
+ int start = 2, count = 3;\r
+ IList<int> list2 = list.View(start, count);\r
+ Assert.IsTrue(list.Check(), "list check before Reverse");\r
+ list2.Reverse();\r
+ Assert.IsTrue(list.Check(), "list check after Reverse");\r
+ checkDisposed(true, start, count);\r
+ }\r
+ [Test]\r
+ public void Sort()\r
+ {\r
+ int start = 2, count = 3;\r
+ IList<int> list2 = list.View(start, count);\r
+ Assert.IsTrue(list.Check(), "list check before Sort");\r
+ list2.Sort();\r
+ Assert.IsTrue(list.Check(), "list check after Sort");\r
+ checkDisposed(false, start, count);\r
+ }\r
+ [Test]\r
+ public void Shuffle()\r
+ {\r
+ int start = 2, count = 3;\r
+ IList<int> list2 = list.View(start, count);\r
+ Assert.IsTrue(list.Check(), "list check before Shuffle");\r
+ list2.Shuffle();\r
+ Assert.IsTrue(list.Check(), "list check after Shuffle");\r
+ checkDisposed(false, start, count);\r
+ }\r
\r
\r
- [TearDown]\r
- public void Dispose() { list = null; }\r
- }\r
}\r
\r
\r
- namespace Range\r
- {\r
- [TestFixture]\r
- public class Range\r
- {\r
- private IList<int> lst;\r
+ [TestFixture]\r
+ public class Validity\r
+ {\r
+ IList<int> list;\r
+ IList<int> view;\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ list = new LinkedList<int>();\r
+ for (int i = 0; i < 6; i++)\r
+ list.Add(i);\r
+ view = list.View(2, 3);\r
+ view.Dispose();\r
+ }\r
+ [TearDown]\r
+ public void Dispose()\r
+ {\r
+ list = null;\r
+ view = null;\r
+ }\r
+\r
+ //Properties\r
+\r
+ //\r
+ /*ActiveEvents,\r
+AllowsDuplicates,\r
+ContainsSpeed,\r
+Count,\r
+CountSpeed,\r
+Direction,\r
+DuplicatesByCounting,\r
+FIFO,\r
+First,\r
+EqualityComparer,\r
+IsEmpty,\r
+IsReadOnly,\r
+this[int index],\r
+this[int start, int count],\r
+Last,\r
+Offset,\r
+SyncRoot,\r
+Underlying\r
+*/\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void Add()\r
+ {\r
+ view.Add(5);\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void AddAll_int_()\r
+ {\r
+ view.AddAll<int>(new int[] { });\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void AddAll()\r
+ {\r
+ view.AddAll<int>(new int[] { });\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void All()\r
+ {\r
+ view.All(delegate(int i) { return false; });\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void Apply()\r
+ {\r
+ view.Apply(delegate(int i) { });\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void Backwards()\r
+ {\r
+ view.Backwards();\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void Choose()\r
+ {\r
+ view.Choose();\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void Contains()\r
+ {\r
+ view.Contains(0);\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void Clear()\r
+ {\r
+ view.Clear();\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void ContainsAll()\r
+ {\r
+ view.ContainsAll<int>(new int[] { });\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void ContainsCount()\r
+ {\r
+ view.ContainsCount(0);\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void CopyTo()\r
+ {\r
+ view.CopyTo(new int[1], 0);\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void Dequeue()\r
+ {\r
+ ((LinkedList<int>)view).Dequeue();\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void Enqueue()\r
+ {\r
+ ((LinkedList<int>)view).Enqueue(0);\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void Exists()\r
+ {\r
+ view.Exists(delegate(int i) { return false; });\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void Filter()\r
+ {\r
+ view.Filter(delegate(int i) { return true; });\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void Find()\r
+ {\r
+ int i = 0;\r
+ view.Find(ref i);\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void FindAll()\r
+ {\r
+ view.FindAll(delegate(int i) { return false; });\r
+ }\r
+ [Test]\r
+ [ExpectedException(typeof(ViewDisposedException))]\r
+ public void FindOrAdd()\r
+ {\r
+ int i = 0;\r
+ view.FindOrAdd(ref i);\r
+ }\r
+\r
+ //TODO: wonder if it is allright to wait with the exception till the enumerator is actually used?\r
+ /* [Test]\r
+ [ExpectedException(typeof(ListDisposedException))]\r
+ public void GetEnumerator()\r
+ {\r
+ view.GetEnumerator();\r
+ }\r
+ */\r
+ /*Method overview\r
+ Check(),\r
+ checkRange(int start, int count),\r
+ Dispose(),\r
+ Equals(object obj),\r
+ Finalize(),\r
+ fireBagItemsAdded(T item, int count),\r
+ fireBagItemsRemoved(T item, int count),\r
+ fireCollectionChanged(),\r
+ fireCollectionCleared(int start, int count),\r
+ fireItemAdded(T item),\r
+ fireItemInserted(T item, int index),\r
+ fireItemRemoved(T item),\r
+ fireItemRemovedAt(T item, int index),\r
+ GetEnumerator(),\r
+ GetHashCode(),\r
+ GetSequencedHashCode(),\r
+ GetType(),\r
+ GetUnsequencedHashCode(),\r
+ IndexOf(T item),\r
+ Insert(int i, T item),\r
+ ViewOf().InsertLast(T item, T target),\r
+ InsertAll(int i, IEnumerable<T> items),\r
+ ViewOf().InsertFirst(T item, T target),\r
+ InsertFirst(T item),\r
+ InsertLast(T item),\r
+ IsSorted(SCG.IComparer<T> c),\r
+ LastIndexOf(T item),\r
+ LastViewOf(T item),\r
+ Map<V>(Fun<T,V> mapper),\r
+ Map<V>(Fun<T,V> mapper, SCG.IEqualityComparer<V> equalityComparer),\r
+ MemberwiseClone(),\r
+ modifycheck(int stamp),\r
+ Pop(),\r
+ Push(T item),\r
+ Remove(),\r
+ Remove(T item),\r
+ Remove(T item, out T removeditem),\r
+ RemoveAll(IEnumerable<T> items),\r
+ RemoveAllCopies(T item),\r
+ RemoveAt(int i),\r
+ RemoveFirst(),\r
+ RemoveInterval(int start, int count),\r
+ RemoveLast(),\r
+ RetainAll(IEnumerable<T> items),\r
+ Reverse(),\r
+ Reverse(int start, int count),\r
+ SequencedEquals(ISequenced<T> that),\r
+ Shuffle(),\r
+ Shuffle(System.Random rnd),\r
+ Slide(int offset),\r
+ Slide(int offset, int size),\r
+ Sort(),\r
+ Sort(SCG.IComparer<T> c),\r
+ ToArray(),\r
+ ToString(),\r
+ UnsequencedEquals(ICollection<T> that),\r
+ Update(T item),\r
+ Update(T item, out T olditem),\r
+ updatecheck(),\r
+ UpdateOrAdd(T item),\r
+ UpdateOrAdd(T item, out T olditem),\r
+ View(int start, int count),\r
+ ViewOf(T item)\r
+ */\r
+ }\r
+ }\r
+\r
+\r
\r
\r
- [SetUp]\r
- public void Init() { lst = new LinkedList<int>(); }\r
+ namespace LinkedListOfTreesORLists\r
+ {\r
+ [TestFixture]\r
+ public class MultiLevelUnorderedOfUnOrdered\r
+ {\r
+ private ICollection<int> dit, dat, dut;\r
+\r
+ private ICollection<ICollection<int>> Dit, Dat, Dut;\r
+\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ dit = new LinkedList<int>();\r
+ dat = new TreeSet<int>(Comparer<int>.Default, EqualityComparer<int>.Default);\r
+ dut = new LinkedList<int>();\r
+ dit.Add(2); dit.Add(1);\r
+ dat.Add(1); dat.Add(2);\r
+ dut.Add(3);\r
+ Dit = new LinkedList<ICollection<int>>();\r
+ Dat = new LinkedList<ICollection<int>>();\r
+ Dut = new LinkedList<ICollection<int>>();\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Check()\r
+ {\r
+ Assert.IsTrue(dit.UnsequencedEquals(dat));\r
+ Assert.IsFalse(dit.UnsequencedEquals(dut));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Multi()\r
+ {\r
+ Dit.Add(dit); Dit.Add(dut); Dit.Add(dit);\r
+ Dat.Add(dut); Dat.Add(dit); Dat.Add(dat);\r
+ Assert.IsTrue(Dit.UnsequencedEquals(Dat));\r
+ Assert.IsFalse(Dit.UnsequencedEquals(Dut));\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose()\r
+ {\r
+ dit = dat = dut = null;\r
+ Dit = Dat = Dut = null;\r
+ }\r
+ }\r
\r
\r
- [TearDown]\r
- public void Dispose() { lst = null; }\r
\r
+ [TestFixture]\r
+ public class MultiLevelOrderedOfUnOrdered\r
+ {\r
+ private ICollection<int> dit, dat, dut;\r
+\r
+ private ISequenced<ICollection<int>> Dit, Dat, Dut;\r
+\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ dit = new LinkedList<int>();\r
+ dat = new TreeSet<int>(Comparer<int>.Default, EqualityComparer<int>.Default);\r
+ dut = new LinkedList<int>();\r
+ dit.Add(2); dit.Add(1);\r
+ dat.Add(1); dat.Add(2);\r
+ dut.Add(3);\r
+ Dit = new LinkedList<ICollection<int>>();\r
+ Dat = new LinkedList<ICollection<int>>();\r
+ Dut = new LinkedList<ICollection<int>>();\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Check()\r
+ {\r
+ Assert.IsTrue(dit.UnsequencedEquals(dat));\r
+ Assert.IsFalse(dit.UnsequencedEquals(dut));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Multi()\r
+ {\r
+ Dit.Add(dit); Dit.Add(dut); Dit.Add(dit);\r
+ Dat.Add(dut); Dat.Add(dit); Dat.Add(dat);\r
+ Dut.Add(dit); Dut.Add(dut); Dut.Add(dat);\r
+ Assert.IsFalse(Dit.SequencedEquals(Dat));\r
+ Assert.IsTrue(Dit.SequencedEquals(Dut));\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose()\r
+ {\r
+ dit = dat = dut = null;\r
+ Dit = Dat = Dut = null;\r
+ }\r
+ }\r
\r
- [Test]\r
- public void GetRange()\r
- {\r
- //Assert.IsTrue(IC.eq(lst[0, 0)));\r
- for (int i = 0; i < 10; i++) lst.Add(i);\r
\r
- Assert.IsTrue(IC.eq(lst[0, 3], 0, 1, 2));\r
- Assert.IsTrue(IC.eq(lst[3, 4], 3, 4, 5, 6));\r
- Assert.IsTrue(IC.eq(lst[6, 4], 6, 7, 8, 9));\r
- }\r
\r
+ [TestFixture]\r
+ public class MultiLevelUnOrderedOfOrdered\r
+ {\r
+ private ISequenced<int> dit, dat, dut, dot;\r
+\r
+ private ICollection<ISequenced<int>> Dit, Dat, Dut, Dot;\r
+\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ dit = new TreeSet<int>(Comparer<int>.Default, EqualityComparer<int>.Default);\r
+ dat = new LinkedList<int>();\r
+ dut = new LinkedList<int>();\r
+ dot = new LinkedList<int>();\r
+ dit.Add(2); dit.Add(1);\r
+ dat.Add(2); dat.Add(1);\r
+ dut.Add(3);\r
+ dot.Add(1); dot.Add(2);\r
+ Dit = new LinkedList<ISequenced<int>>();\r
+ Dat = new LinkedList<ISequenced<int>>();\r
+ Dut = new LinkedList<ISequenced<int>>();\r
+ Dot = new LinkedList<ISequenced<int>>();\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Check()\r
+ {\r
+ Assert.IsFalse(dit.SequencedEquals(dat));\r
+ Assert.IsTrue(dit.SequencedEquals(dot));\r
+ Assert.IsFalse(dit.SequencedEquals(dut));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Multi()\r
+ {\r
+ Dit.Add(dit); Dit.Add(dut); Dit.Add(dit);\r
+ Dat.Add(dut); Dat.Add(dit); Dat.Add(dat);\r
+ Dut.Add(dot); Dut.Add(dut); Dut.Add(dit);\r
+ Dot.Add(dit); Dot.Add(dit); Dot.Add(dut);\r
+ Assert.IsTrue(Dit.UnsequencedEquals(Dut));\r
+ Assert.IsFalse(Dit.UnsequencedEquals(Dat));\r
+ Assert.IsTrue(Dit.UnsequencedEquals(Dot));\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose()\r
+ {\r
+ dit = dat = dut = dot = null;\r
+ Dit = Dat = Dut = Dot = null;\r
+ }\r
+ }\r
\r
- [Test]\r
- [ExpectedException(typeof(ArgumentException))]\r
- public void BadGetRange()\r
- {\r
- object foo= lst[0, 11];\r
- }\r
\r
\r
- [Test]\r
- public void Backwards()\r
- {\r
- for (int i = 0; i < 10; i++) lst.Add(i);\r
+ [TestFixture]\r
+ public class MultiLevelOrderedOfOrdered\r
+ {\r
+ private ISequenced<int> dit, dat, dut, dot;\r
+\r
+ private ISequenced<ISequenced<int>> Dit, Dat, Dut, Dot;\r
+\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ dit = new TreeSet<int>(Comparer<int>.Default, EqualityComparer<int>.Default);\r
+ dat = new LinkedList<int>();\r
+ dut = new LinkedList<int>();\r
+ dot = new LinkedList<int>();\r
+ dit.Add(2); dit.Add(1);\r
+ dat.Add(2); dat.Add(1);\r
+ dut.Add(3);\r
+ dot.Add(1); dot.Add(2);\r
+ Dit = new LinkedList<ISequenced<int>>();\r
+ Dat = new LinkedList<ISequenced<int>>();\r
+ Dut = new LinkedList<ISequenced<int>>();\r
+ Dot = new LinkedList<ISequenced<int>>();\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Check()\r
+ {\r
+ Assert.IsFalse(dit.SequencedEquals(dat));\r
+ Assert.IsTrue(dit.SequencedEquals(dot));\r
+ Assert.IsFalse(dit.SequencedEquals(dut));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Multi()\r
+ {\r
+ Dit.Add(dit); Dit.Add(dut); Dit.Add(dit);\r
+ Dat.Add(dut); Dat.Add(dit); Dat.Add(dat);\r
+ Dut.Add(dot); Dut.Add(dut); Dut.Add(dit);\r
+ Dot.Add(dit); Dot.Add(dit); Dot.Add(dut);\r
+ Assert.IsTrue(Dit.SequencedEquals(Dut));\r
+ Assert.IsFalse(Dit.SequencedEquals(Dat));\r
+ Assert.IsFalse(Dit.SequencedEquals(Dot));\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose()\r
+ {\r
+ dit = dat = dut = dot = null;\r
+ Dit = Dat = Dut = Dot = null;\r
+ }\r
+ }\r
+ }\r
\r
- Assert.IsTrue(IC.eq(lst.Backwards(), 9, 8, 7, 6, 5, 4, 3, 2, 1, 0));\r
- Assert.IsTrue(IC.eq(lst[0, 4].Backwards(), 3, 2, 1, 0));\r
- Assert.IsTrue(IC.eq(lst[3, 4].Backwards(), 6, 5, 4, 3));\r
- Assert.IsTrue(IC.eq(lst[6, 4].Backwards(), 9, 8, 7, 6));\r
- }\r
\r
\r
- [Test]\r
- public void DirectionAndCount()\r
- {\r
- for (int i = 0; i < 10; i++) lst.Add(i);\r
\r
- Assert.AreEqual(EnumerationDirection.Forwards, lst.Direction);\r
- Assert.AreEqual(EnumerationDirection.Forwards, lst[3, 7].Direction);\r
- Assert.AreEqual(EnumerationDirection.Backwards, lst[3, 7].Backwards().Direction);\r
- Assert.AreEqual(EnumerationDirection.Backwards, lst.Backwards().Direction);\r
- Assert.AreEqual(4, lst[3, 4].Count);\r
- Assert.AreEqual(4, lst[3, 4].Backwards().Count);\r
- Assert.AreEqual(10, lst.Backwards().Count);\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(InvalidOperationException))]\r
- public void MoveNextAfterUpdate()\r
- {\r
- for (int i = 0; i < 10; i++) lst.Add(i);\r
-\r
- foreach (int i in lst)\r
- {\r
- lst.Add(45 + i);\r
- }\r
- }\r
- }\r
- }\r
-\r
-\r
-\r
-\r
- namespace View\r
- {\r
- [TestFixture]\r
- public class Simple\r
- {\r
- LinkedList<int> list, view;\r
-\r
-\r
- [SetUp]\r
- public void Init()\r
- {\r
- list = new LinkedList<int>();\r
- list.Add(0);list.Add(1);list.Add(2);list.Add(3);\r
- view = (LinkedList<int>)list.View(1, 2);\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose()\r
- {\r
- list = view = null;\r
- }\r
-\r
-\r
- void check()\r
- {\r
- Assert.IsTrue(list.Check());\r
- Assert.IsTrue(view.Check());\r
- }\r
-\r
- [Test]\r
- [ExpectedException(typeof(ArgumentException), "Target item not found")]\r
- public void BadInsertAfterLow()\r
- {\r
- view.InsertAfter(876, 0);\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(ArgumentException), "Target item not found")]\r
- public void BadInsertAfterHigh()\r
- {\r
- view.InsertAfter(876, 0);\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(ArgumentException), "Target item not found")]\r
- public void BadInsertBeforeLow()\r
- {\r
- view.InsertBefore(876, 0);\r
- }\r
-\r
-\r
- [Test]\r
- [ExpectedException(typeof(ArgumentException), "Target item not found")]\r
- public void BadInsertBeforeHigh()\r
- {\r
- view.InsertBefore(876, 0);\r
- }\r
-\r
-\r
-\r
- [Test]\r
- public void Add()\r
- {\r
- check();\r
- Assert.IsTrue(IC.eq(list, 0, 1, 2, 3));\r
- Assert.IsTrue(IC.eq(view, 1, 2));\r
- view.InsertFirst(10);\r
- check();\r
- Assert.IsTrue(IC.eq(list, 0, 10, 1, 2, 3));\r
- Assert.IsTrue(IC.eq(view, 10, 1, 2));\r
- view.Clear();\r
- Assert.IsFalse(view.IsReadOnly);\r
- Assert.IsTrue(view.AllowsDuplicates);\r
- Assert.IsTrue(view.IsEmpty);\r
- check();\r
- Assert.IsTrue(IC.eq(list, 0, 3));\r
- Assert.IsTrue(IC.eq(view));\r
- view.Add(8);\r
- Assert.IsFalse(view.IsEmpty);\r
- Assert.IsTrue(view.AllowsDuplicates);\r
- Assert.IsFalse(view.IsReadOnly);\r
- check();\r
- Assert.IsTrue(IC.eq(list, 0, 8, 3));\r
- Assert.IsTrue(IC.eq(view, 8));\r
- view.Add(12);\r
- check();\r
- Assert.IsTrue(IC.eq(list, 0, 8, 12, 3));\r
- Assert.IsTrue(IC.eq(view, 8, 12));\r
- view.InsertAfter(15, 12);\r
- check();\r
- Assert.IsTrue(IC.eq(list, 0, 8, 12, 15, 3));\r
- Assert.IsTrue(IC.eq(view, 8, 12, 15));\r
- view.InsertBefore(18, 12);\r
- check();\r
- Assert.IsTrue(IC.eq(list, 0, 8, 18, 12, 15, 3));\r
- Assert.IsTrue(IC.eq(view, 8, 18, 12, 15));\r
-\r
- LinkedList<int> lst2 = new LinkedList<int>();\r
-\r
- lst2.Add(90);lst2.Add(92);\r
- view.AddAll(lst2);\r
- check();\r
- Assert.IsTrue(IC.eq(list, 0, 8, 18, 12, 15, 90, 92, 3));\r
- Assert.IsTrue(IC.eq(view, 8, 18, 12, 15, 90, 92));\r
- view.InsertLast(66);\r
- check();\r
- Assert.IsTrue(IC.eq(list, 0, 8, 18, 12, 15, 90, 92, 66, 3));\r
- Assert.IsTrue(IC.eq(view, 8, 18, 12, 15, 90, 92, 66));\r
- }\r
-\r
-\r
- [Test]\r
- public void Bxxx()\r
- {\r
- Assert.IsTrue(IC.eq(view.Backwards(), 2, 1));\r
- Assert.AreSame(list, view.Underlying);\r
- Assert.IsNull(list.Underlying);\r
- Assert.AreEqual(EnumerationDirection.Forwards, view.Direction);\r
- Assert.AreEqual(EnumerationDirection.Backwards, view.Backwards().Direction);\r
- Assert.AreEqual(0,list.Offset);\r
- Assert.AreEqual(1,view.Offset);\r
- }\r
-\r
-\r
- [Test]\r
- public void Contains()\r
- {\r
- Assert.IsTrue(view.Contains(1));\r
- Assert.IsFalse(view.Contains(0));\r
-\r
- LinkedList<int> lst2 = new LinkedList<int>();\r
-\r
- lst2.Add(2);\r
- Assert.IsTrue(view.ContainsAll(lst2));\r
- lst2.Add(3);\r
- Assert.IsFalse(view.ContainsAll(lst2));\r
- Assert.AreEqual(Speed.Linear, view.ContainsSpeed);\r
- Assert.AreEqual(2, view.Count);\r
- view.Add(1);\r
- Assert.AreEqual(1, view.ContainsCount(2));\r
- Assert.AreEqual(2, view.ContainsCount(1));\r
- Assert.AreEqual(3, view.Count);\r
- }\r
-\r
-\r
- [Test]\r
- public void CreateView()\r
- {\r
- LinkedList<int> view2 = (LinkedList<int>)view.View(1, 0);\r
-\r
- Assert.AreSame(list, view2.Underlying);\r
- }\r
+ namespace HashingAndEquals\r
+ {\r
+ [TestFixture]\r
+ public class ISequenced\r
+ {\r
+ private ISequenced<int> dit, dat, dut;\r
+\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ dit = new LinkedList<int>();\r
+ dat = new LinkedList<int>();\r
+ dut = new LinkedList<int>();\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void EmptyEmpty()\r
+ {\r
+ Assert.IsTrue(dit.SequencedEquals(dat));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void EmptyNonEmpty()\r
+ {\r
+ dit.Add(3);\r
+ Assert.IsFalse(dit.SequencedEquals(dat));\r
+ Assert.IsFalse(dat.SequencedEquals(dit));\r
+ }\r
+\r
+ [Test]\r
+ public void HashVal()\r
+ {\r
+ Assert.AreEqual(CHC.sequencedhashcode(), dit.GetSequencedHashCode());\r
+ dit.Add(3);\r
+ Assert.AreEqual(CHC.sequencedhashcode(3), dit.GetSequencedHashCode());\r
+ dit.Add(7);\r
+ Assert.AreEqual(CHC.sequencedhashcode(3, 7), dit.GetSequencedHashCode());\r
+ Assert.AreEqual(CHC.sequencedhashcode(), dut.GetSequencedHashCode());\r
+ dut.Add(7);\r
+ Assert.AreEqual(CHC.sequencedhashcode(7), dut.GetSequencedHashCode());\r
+ dut.Add(3);\r
+ Assert.AreEqual(CHC.sequencedhashcode(7, 3), dut.GetSequencedHashCode());\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void EqualHashButDifferent()\r
+ {\r
+ dit.Add(0); dit.Add(31);\r
+ dat.Add(1); dat.Add(0);\r
+ Assert.AreEqual(dit.GetSequencedHashCode(), dat.GetSequencedHashCode());\r
+ Assert.IsFalse(dit.SequencedEquals(dat));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Normal()\r
+ {\r
+ dit.Add(3);\r
+ dit.Add(7);\r
+ dat.Add(3);\r
+ Assert.IsFalse(dit.SequencedEquals(dat));\r
+ Assert.IsFalse(dat.SequencedEquals(dit));\r
+ dat.Add(7);\r
+ Assert.IsTrue(dit.SequencedEquals(dat));\r
+ Assert.IsTrue(dat.SequencedEquals(dit));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void WrongOrder()\r
+ {\r
+ dit.Add(3);\r
+ dut.Add(3);\r
+ Assert.IsTrue(dit.SequencedEquals(dut));\r
+ Assert.IsTrue(dut.SequencedEquals(dit));\r
+ dit.Add(7);\r
+ ((LinkedList<int>)dut).InsertFirst(7);\r
+ Assert.IsFalse(dit.SequencedEquals(dut));\r
+ Assert.IsFalse(dut.SequencedEquals(dit));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Reflexive()\r
+ {\r
+ Assert.IsTrue(dit.SequencedEquals(dit));\r
+ dit.Add(3);\r
+ Assert.IsTrue(dit.SequencedEquals(dit));\r
+ dit.Add(7);\r
+ Assert.IsTrue(dit.SequencedEquals(dit));\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose()\r
+ {\r
+ dit = null;\r
+ dat = null;\r
+ dut = null;\r
+ }\r
+ }\r
+\r
+\r
+\r
+ [TestFixture]\r
+ public class IEditableCollection\r
+ {\r
+ private ICollection<int> dit, dat, dut;\r
+\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ dit = new LinkedList<int>();\r
+ dat = new LinkedList<int>();\r
+ dut = new LinkedList<int>();\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void EmptyEmpty()\r
+ {\r
+ Assert.IsTrue(dit.UnsequencedEquals(dat));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void EmptyNonEmpty()\r
+ {\r
+ dit.Add(3);\r
+ Assert.IsFalse(dit.UnsequencedEquals(dat));\r
+ Assert.IsFalse(dat.UnsequencedEquals(dit));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void HashVal()\r
+ {\r
+ Assert.AreEqual(CHC.unsequencedhashcode(), dit.GetUnsequencedHashCode());\r
+ dit.Add(3);\r
+ Assert.AreEqual(CHC.unsequencedhashcode(3), dit.GetUnsequencedHashCode());\r
+ dit.Add(7);\r
+ Assert.AreEqual(CHC.unsequencedhashcode(3, 7), dit.GetUnsequencedHashCode());\r
+ Assert.AreEqual(CHC.unsequencedhashcode(), dut.GetUnsequencedHashCode());\r
+ dut.Add(3);\r
+ Assert.AreEqual(CHC.unsequencedhashcode(3), dut.GetUnsequencedHashCode());\r
+ dut.Add(7);\r
+ Assert.AreEqual(CHC.unsequencedhashcode(7, 3), dut.GetUnsequencedHashCode());\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void EqualHashButDifferent()\r
+ {\r
+ dit.Add(-1657792980); dit.Add(-1570288808);\r
+ dat.Add(1862883298); dat.Add(-272461342);\r
+ Assert.AreEqual(dit.GetUnsequencedHashCode(), dat.GetUnsequencedHashCode());\r
+ Assert.IsFalse(dit.UnsequencedEquals(dat));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Normal()\r
+ {\r
+ dit.Add(3);\r
+ dit.Add(7);\r
+ dat.Add(3);\r
+ Assert.IsFalse(dit.UnsequencedEquals(dat));\r
+ Assert.IsFalse(dat.UnsequencedEquals(dit));\r
+ dat.Add(7);\r
+ Assert.IsTrue(dit.UnsequencedEquals(dat));\r
+ Assert.IsTrue(dat.UnsequencedEquals(dit));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void WrongOrder()\r
+ {\r
+ dit.Add(3);\r
+ dut.Add(3);\r
+ Assert.IsTrue(dit.UnsequencedEquals(dut));\r
+ Assert.IsTrue(dut.UnsequencedEquals(dit));\r
+ dit.Add(7);\r
+ dut.Add(7);\r
+ Assert.IsTrue(dit.UnsequencedEquals(dut));\r
+ Assert.IsTrue(dut.UnsequencedEquals(dit));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Reflexive()\r
+ {\r
+ Assert.IsTrue(dit.UnsequencedEquals(dit));\r
+ dit.Add(3);\r
+ Assert.IsTrue(dit.UnsequencedEquals(dit));\r
+ dit.Add(7);\r
+ Assert.IsTrue(dit.UnsequencedEquals(dit));\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose()\r
+ {\r
+ dit = null;\r
+ dat = null;\r
+ dut = null;\r
+ }\r
+ }\r
+\r
+\r
+\r
+ [TestFixture]\r
+ public class MultiLevelUnorderedOfUnOrdered\r
+ {\r
+ private ICollection<int> dit, dat, dut;\r
+\r
+ private ICollection<ICollection<int>> Dit, Dat, Dut;\r
+\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ dit = new LinkedList<int>();\r
+ dat = new LinkedList<int>();\r
+ dut = new LinkedList<int>();\r
+ dit.Add(2); dit.Add(1);\r
+ dat.Add(1); dat.Add(2);\r
+ dut.Add(3);\r
+ Dit = new LinkedList<ICollection<int>>();\r
+ Dat = new LinkedList<ICollection<int>>();\r
+ Dut = new LinkedList<ICollection<int>>();\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Check()\r
+ {\r
+ Assert.IsTrue(dit.UnsequencedEquals(dat));\r
+ Assert.IsFalse(dit.UnsequencedEquals(dut));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Multi()\r
+ {\r
+ Dit.Add(dit); Dit.Add(dut); Dit.Add(dit);\r
+ Dat.Add(dut); Dat.Add(dit); Dat.Add(dat);\r
+ Assert.IsTrue(Dit.UnsequencedEquals(Dat));\r
+ Assert.IsFalse(Dit.UnsequencedEquals(Dut));\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose()\r
+ {\r
+ dit = dat = dut = null;\r
+ Dit = Dat = Dut = null;\r
+ }\r
+ }\r
+\r
\r
\r
- [Test]\r
- public void FIFO()\r
- {\r
- Assert.IsTrue(view.FIFO);\r
- view.Add(23);view.Add(24);view.Add(25);\r
- check();\r
- Assert.IsTrue(IC.eq(view, 1, 2, 23, 24, 25));\r
- Assert.AreEqual(1, view.Remove());\r
- check();\r
- Assert.IsTrue(IC.eq(view, 2, 23, 24, 25));\r
- view.FIFO = false;\r
- Assert.IsFalse(view.FIFO);\r
- Assert.AreEqual(25, view.Remove());\r
- check();\r
- Assert.IsTrue(IC.eq(view, 2, 23, 24));\r
- }\r
-\r
-\r
- [Test]\r
- public void MapEtc()\r
- {\r
- LinkedList<double> dbl = (LinkedList<double>)view.Map(new Mapper<int,double>(delegate(int i){return i/10.0;}));\r
-\r
- Assert.IsTrue(dbl.Check());\r
- Assert.AreEqual(0.1, dbl[0]);\r
- Assert.AreEqual(0.2, dbl[1]);\r
- for (int i = 0; i < 10; i++) view.Add(i);\r
-\r
- list = (LinkedList<int>)view.FindAll(new Filter<int>(delegate(int i){return i%4==1;}));\r
- Assert.IsTrue(list.Check());\r
- Assert.IsTrue(IC.eq(list, 1, 1, 5, 9));\r
- }\r
-\r
-\r
- [Test]\r
- public void FL()\r
- {\r
- Assert.AreEqual(1, view.First);\r
- Assert.AreEqual(2, view.Last);\r
- }\r
-\r
-\r
- [Test]\r
- public void Indexing()\r
- {\r
- list.Clear();\r
- for (int i = 0; i < 20; i++) list.Add(i);\r
-\r
- view = (LinkedList<int>)list.View(5, 7);\r
- for (int i = 0; i < 7; i++) Assert.AreEqual(i + 5, view[i]);\r
-\r
- for (int i = 0; i < 7; i++) Assert.AreEqual(i, view.IndexOf(i + 5));\r
-\r
- for (int i = 0; i < 7; i++) Assert.AreEqual(i, view.LastIndexOf(i + 5));\r
- }\r
-\r
-\r
- [Test]\r
- public void INsert()\r
- {\r
- view.Insert(0, 34);\r
- view.Insert(1, 35);\r
- view.Insert(4, 36);\r
- Assert.IsTrue(view.Check());\r
- Assert.IsTrue(IC.eq(view, 34, 35, 1, 2, 36));\r
-\r
- IList<int> list2 = new LinkedList<int>();\r
-\r
- list2.AddAll(view);\r
- view.InsertAll(3, list2);\r
- Assert.IsTrue(view.Check());\r
- Assert.IsTrue(IC.eq(view, 34, 35, 1, 34, 35, 1, 2, 36, 2, 36));\r
- }\r
-\r
-\r
- [Test]\r
- public void Sort()\r
- {\r
- view.Add(45);view.Add(47);view.Add(46);view.Add(48);\r
- Assert.IsFalse(view.IsSorted(new IC()));\r
- view.Sort(new IC());\r
- check();\r
- Assert.IsTrue(IC.eq(list, 0, 1, 2, 45, 46, 47, 48, 3));\r
- Assert.IsTrue(IC.eq(view, 1, 2, 45, 46, 47, 48));\r
- }\r
-\r
-\r
- [Test]\r
- public void Remove()\r
- {\r
- view.Add(1);view.Add(5);view.Add(3);view.Add(1);view.Add(3);view.Add(0);\r
- Assert.IsTrue(IC.eq(view, 1, 2, 1, 5, 3, 1, 3, 0));\r
- Assert.IsTrue(view.Remove(1));\r
- check();\r
- Assert.IsTrue(IC.eq(view, 2, 1, 5, 3, 1, 3, 0));\r
- Assert.IsTrue(view.Remove(1));\r
- check();\r
- Assert.IsTrue(IC.eq(view, 2, 5, 3, 1, 3, 0));\r
- Assert.IsTrue(view.Remove(0));\r
- check();\r
- Assert.IsTrue(IC.eq(view, 2, 5, 3, 1, 3));\r
- view.RemoveAllCopies(3);\r
- check();\r
- Assert.IsTrue(IC.eq(view, 2, 5, 1));\r
- Assert.IsTrue(IC.eq(list, 0, 2, 5, 1, 3));\r
- view.Add(1);view.Add(5);view.Add(3);view.Add(1);view.Add(3);view.Add(0);\r
- Assert.IsTrue(IC.eq(view, 2, 5, 1, 1, 5, 3, 1, 3, 0));\r
-\r
- LinkedList<int> l2 = new LinkedList<int>();\r
-\r
- l2.Add(1);l2.Add(2);l2.Add(2);l2.Add(3);l2.Add(1);\r
- view.RemoveAll(l2);\r
- check();\r
- Assert.IsTrue(IC.eq(view, 5, 5, 1, 3, 0));\r
- view.RetainAll(l2);\r
- check();\r
- Assert.IsTrue(IC.eq(view, 1, 3));\r
- view.Add(2);view.Add(4);view.Add(5);\r
- Assert.AreEqual(1, view.RemoveAt(0));\r
- Assert.AreEqual(5, view.RemoveAt(3));\r
- Assert.AreEqual(2, view.RemoveAt(1));\r
- check();\r
- Assert.IsTrue(IC.eq(view, 3, 4));\r
- view.Add(8);\r
- Assert.AreEqual(3, view.RemoveFirst());\r
- Assert.AreEqual(8, view.RemoveLast());\r
- view.Add(2);view.Add(5);view.Add(3);view.Add(1);\r
- view.RemoveInterval(1, 2);\r
- check();\r
- Assert.IsTrue(IC.eq(view, 4, 3, 1));\r
- }\r
-\r
-\r
- [Test]\r
- public void Reverse()\r
- {\r
- view.Clear();\r
- for (int i = 0; i < 10; i++) view.Add(10 + i);\r
-\r
- view.Reverse(3, 4);\r
- check();\r
- Assert.IsTrue(IC.eq(view, 10, 11, 12, 16, 15, 14, 13, 17, 18, 19));\r
- view.Reverse();\r
- Assert.IsTrue(IC.eq(view, 19, 18, 17, 13, 14, 15, 16, 12, 11, 10));\r
- Assert.IsTrue(IC.eq(list, 0, 19, 18, 17, 13, 14, 15, 16, 12, 11, 10, 3));\r
- }\r
-\r
-\r
- [Test]\r
- public void Slide()\r
- {\r
- view.Slide(1);\r
- check();\r
- Assert.IsTrue(IC.eq(view, 2, 3));\r
- view.Slide(-2);\r
- check();\r
- Assert.IsTrue(IC.eq(view, 0, 1));\r
- view.Slide(0, 3);\r
- check();\r
- Assert.IsTrue(IC.eq(view, 0, 1, 2));\r
- view.Slide(2, 1);\r
- check();\r
- Assert.IsTrue(IC.eq(view, 2));\r
- view.Slide(-1, 0);\r
- check();\r
- Assert.IsTrue(IC.eq(view));\r
- view.Add(28);\r
- Assert.IsTrue(IC.eq(list, 0, 28, 1, 2, 3));\r
- }\r
- [Test]\r
- public void Iterate()\r
- {\r
- list.Clear();\r
- view = null;\r
- foreach (int i in new int[] { 2, 4, 8, 13, 6, 1, 2, 7 }) list.Add(i);\r
-\r
- view = (LinkedList<int>)list.View(list.Count - 2, 2);\r
- while (true)\r
- {\r
- //Console.WriteLine("View: {0}: {1} --> {2}", view.Count, view.First, view.Last);\r
- if ((view.Last - view.First) % 2 == 1)\r
- view.Insert(1, 666);\r
- check();\r
- if (view.Offset == 0)\r
- break;\r
- else\r
- view.Slide(-1,2);\r
- }\r
- //foreach (int i in list) Console.Write(" " + i);\r
- //Assert.IsTrue(list.Check());\r
- Assert.IsTrue(IC.eq(list, 2, 4, 8, 666, 13, 6, 1, 666, 2, 666, 7));\r
- }\r
-\r
-\r
- [Test]\r
- public void SyncRoot()\r
- {\r
- Assert.AreSame(view.SyncRoot, list.SyncRoot);\r
- }\r
- }\r
- }\r
-\r
-\r
-\r
-\r
- namespace LinkedListOfTreesORLists\r
- {\r
- [TestFixture]\r
- public class MultiLevelUnorderedOfUnOrdered\r
- {\r
- private ICollection<int> dit, dat, dut;\r
-\r
- private ICollection<ICollection<int>> Dit, Dat, Dut;\r
-\r
-\r
- [SetUp]\r
- public void Init()\r
- {\r
- dit = new LinkedList<int>();\r
- dat = new TreeSet<int>(new IC());\r
- dut = new LinkedList<int>();\r
- dit.Add(2);dit.Add(1);\r
- dat.Add(1);dat.Add(2);\r
- dut.Add(3);\r
- Dit = new LinkedList<ICollection<int>>();\r
- Dat = new LinkedList<ICollection<int>>();\r
- Dut = new LinkedList<ICollection<int>>();\r
- }\r
-\r
-\r
- [Test]\r
- public void Check()\r
- {\r
- Assert.IsTrue(dit.Equals(dat));\r
- Assert.IsFalse(dit.Equals(dut));\r
- }\r
-\r
-\r
- [Test]\r
- public void Multi()\r
- {\r
- Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
- Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
- Assert.IsTrue(Dit.Equals(Dat));\r
- Assert.IsFalse(Dit.Equals(Dut));\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose()\r
- {\r
- dit = dat = dut = null;\r
- Dit = Dat = Dut = null;\r
- }\r
- }\r
-\r
-\r
-\r
- [TestFixture]\r
- public class MultiLevelOrderedOfUnOrdered\r
- {\r
- private ICollection<int> dit, dat, dut;\r
-\r
- private ISequenced<ICollection<int>> Dit, Dat, Dut;\r
-\r
-\r
- [SetUp]\r
- public void Init()\r
- {\r
- dit = new LinkedList<int>();\r
- dat = new TreeSet<int>(new IC());\r
- dut = new LinkedList<int>();\r
- dit.Add(2);dit.Add(1);\r
- dat.Add(1);dat.Add(2);\r
- dut.Add(3);\r
- Dit = new LinkedList<ICollection<int>>();\r
- Dat = new LinkedList<ICollection<int>>();\r
- Dut = new LinkedList<ICollection<int>>();\r
- }\r
-\r
-\r
- [Test]\r
- public void Check()\r
- {\r
- Assert.IsTrue(dit.Equals(dat));\r
- Assert.IsFalse(dit.Equals(dut));\r
- }\r
-\r
-\r
- [Test]\r
- public void Multi()\r
- {\r
- Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
- Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
- Dut.Add(dit);Dut.Add(dut);Dut.Add(dat);\r
- Assert.IsFalse(Dit.Equals(Dat));\r
- Assert.IsTrue(Dit.Equals(Dut));\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose()\r
- {\r
- dit = dat = dut = null;\r
- Dit = Dat = Dut = null;\r
- }\r
- }\r
-\r
-\r
-\r
- [TestFixture]\r
- public class MultiLevelUnOrderedOfOrdered\r
- {\r
- private ISequenced<int> dit, dat, dut, dot;\r
-\r
- private ICollection<ISequenced<int>> Dit, Dat, Dut, Dot;\r
-\r
-\r
- [SetUp]\r
- public void Init()\r
- {\r
- dit = new TreeSet<int>(new IC());\r
- dat = new LinkedList<int>();\r
- dut = new LinkedList<int>();\r
- dot = new LinkedList<int>();\r
- dit.Add(2);dit.Add(1);\r
- dat.Add(2);dat.Add(1);\r
- dut.Add(3);\r
- dot.Add(1);dot.Add(2);\r
- Dit = new LinkedList<ISequenced<int>>();\r
- Dat = new LinkedList<ISequenced<int>>();\r
- Dut = new LinkedList<ISequenced<int>>();\r
- Dot = new LinkedList<ISequenced<int>>();\r
- }\r
-\r
-\r
- [Test]\r
- public void Check()\r
- {\r
- Assert.IsFalse(dit.Equals(dat));\r
- Assert.IsTrue(dit.Equals(dot));\r
- Assert.IsFalse(dit.Equals(dut));\r
- }\r
-\r
-\r
- [Test]\r
- public void Multi()\r
- {\r
- Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
- Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
- Dut.Add(dot);Dut.Add(dut);Dut.Add(dit);\r
- Dot.Add(dit);Dot.Add(dit);Dot.Add(dut);\r
- Assert.IsTrue(Dit.Equals(Dut));\r
- Assert.IsFalse(Dit.Equals(Dat));\r
- Assert.IsTrue(Dit.Equals(Dot));\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose()\r
- {\r
- dit = dat = dut = dot = null;\r
- Dit = Dat = Dut = Dot = null;\r
- }\r
- }\r
-\r
-\r
-\r
- [TestFixture]\r
- public class MultiLevelOrderedOfOrdered\r
- {\r
- private ISequenced<int> dit, dat, dut, dot;\r
-\r
- private ISequenced<ISequenced<int>> Dit, Dat, Dut, Dot;\r
-\r
-\r
- [SetUp]\r
- public void Init()\r
- {\r
- dit = new TreeSet<int>(new IC());\r
- dat = new LinkedList<int>();\r
- dut = new LinkedList<int>();\r
- dot = new LinkedList<int>();\r
- dit.Add(2);dit.Add(1);\r
- dat.Add(2);dat.Add(1);\r
- dut.Add(3);\r
- dot.Add(1);dot.Add(2);\r
- Dit = new LinkedList<ISequenced<int>>();\r
- Dat = new LinkedList<ISequenced<int>>();\r
- Dut = new LinkedList<ISequenced<int>>();\r
- Dot = new LinkedList<ISequenced<int>>();\r
- }\r
-\r
-\r
- [Test]\r
- public void Check()\r
- {\r
- Assert.IsFalse(dit.Equals(dat));\r
- Assert.IsTrue(dit.Equals(dot));\r
- Assert.IsFalse(dit.Equals(dut));\r
- }\r
-\r
-\r
- [Test]\r
- public void Multi()\r
- {\r
- Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
- Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
- Dut.Add(dot);Dut.Add(dut);Dut.Add(dit);\r
- Dot.Add(dit);Dot.Add(dit);Dot.Add(dut);\r
- Assert.IsTrue(Dit.Equals(Dut));\r
- Assert.IsFalse(Dit.Equals(Dat));\r
- Assert.IsFalse(Dit.Equals(Dot));\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose()\r
- {\r
- dit = dat = dut = dot = null;\r
- Dit = Dat = Dut = Dot = null;\r
- }\r
- }\r
- }\r
-\r
-\r
-\r
-\r
- namespace HashingAndEquals\r
- {\r
- [TestFixture]\r
- public class ISequenced\r
- {\r
- private ISequenced<int> dit, dat, dut;\r
-\r
-\r
- [SetUp]\r
- public void Init()\r
- {\r
- dit = new LinkedList<int>();\r
- dat = new LinkedList<int>();\r
- dut = new LinkedList<int>();\r
- }\r
-\r
-\r
- [Test]\r
- public void EmptyEmpty()\r
- {\r
- Assert.IsTrue(dit.Equals(dat));\r
- }\r
-\r
-\r
- [Test]\r
- public void EmptyNonEmpty()\r
- {\r
- dit.Add(3);\r
- Assert.IsFalse(dit.Equals(dat));\r
- Assert.IsFalse(dat.Equals(dit));\r
- }\r
-\r
-\r
- public int hasher(params int[] items)\r
- {\r
- int retval = 0;\r
-\r
- foreach (int i in items)\r
- retval = retval * 31 + i;\r
-\r
- return retval;\r
- }\r
-\r
-\r
- [Test]\r
- public void HashVal()\r
- {\r
- Assert.AreEqual(hasher(), dit.GetHashCode());\r
- dit.Add(3);\r
- Assert.AreEqual(hasher(3), dit.GetHashCode());\r
- dit.Add(7);\r
- Assert.AreEqual(hasher(3, 7), dit.GetHashCode());\r
- Assert.AreEqual(hasher(), dut.GetHashCode());\r
- dut.Add(7);\r
- Assert.AreEqual(hasher(7), dut.GetHashCode());\r
- dut.Add(3);\r
- Assert.AreEqual(hasher(7, 3), dut.GetHashCode());\r
- }\r
-\r
-\r
- [Test]\r
- public void EqualHashButDifferent()\r
- {\r
- dit.Add(0);dit.Add(31);\r
- dat.Add(1);dat.Add(0);\r
- Assert.AreEqual(dit.GetHashCode(), dat.GetHashCode());\r
- Assert.IsFalse(dit.Equals(dat));\r
- }\r
-\r
-\r
- [Test]\r
- public void Normal()\r
- {\r
- dit.Add(3);\r
- dit.Add(7);\r
- dat.Add(3);\r
- Assert.IsFalse(dit.Equals(dat));\r
- Assert.IsFalse(dat.Equals(dit));\r
- dat.Add(7);\r
- Assert.IsTrue(dit.Equals(dat));\r
- Assert.IsTrue(dat.Equals(dit));\r
- }\r
-\r
-\r
- [Test]\r
- public void WrongOrder()\r
- {\r
- dit.Add(3);\r
- dut.Add(3);\r
- Assert.IsTrue(dit.Equals(dut));\r
- Assert.IsTrue(dut.Equals(dit));\r
- dit.Add(7);\r
- ((LinkedList<int>)dut).InsertFirst(7);\r
- Assert.IsFalse(dit.Equals(dut));\r
- Assert.IsFalse(dut.Equals(dit));\r
- }\r
-\r
-\r
- [Test]\r
- public void Reflexive()\r
- {\r
- Assert.IsTrue(dit.Equals(dit));\r
- dit.Add(3);\r
- Assert.IsTrue(dit.Equals(dit));\r
- dit.Add(7);\r
- Assert.IsTrue(dit.Equals(dit));\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose()\r
- {\r
- dit = null;\r
- dat = null;\r
- dut = null;\r
- }\r
- }\r
-\r
-\r
-\r
- [TestFixture]\r
- public class IEditableCollection\r
- {\r
- private ICollection<int> dit, dat, dut;\r
-\r
-\r
- [SetUp]\r
- public void Init()\r
- {\r
- dit = new LinkedList<int>();\r
- dat = new LinkedList<int>();\r
- dut = new LinkedList<int>();\r
- }\r
-\r
-\r
- [Test]\r
- public void EmptyEmpty()\r
- {\r
- Assert.IsTrue(dit.Equals(dat));\r
- }\r
-\r
-\r
- [Test]\r
- public void EmptyNonEmpty()\r
- {\r
- dit.Add(3);\r
- Assert.IsFalse(dit.Equals(dat));\r
- Assert.IsFalse(dat.Equals(dit));\r
- }\r
-\r
-\r
- public int hasher(int count, params int[] items)\r
- {\r
- int retval = 0;\r
-\r
- foreach (int i in items)\r
- retval ^= i;\r
-\r
- return (count << 16) + retval;\r
- }\r
-\r
-\r
- [Test]\r
- public void HashVal()\r
- {\r
- Assert.AreEqual(hasher(0), dit.GetHashCode());\r
- dit.Add(3);\r
- Assert.AreEqual(hasher(1, 3), dit.GetHashCode());\r
- dit.Add(7);\r
- Assert.AreEqual(hasher(2, 3, 7), dit.GetHashCode());\r
- Assert.AreEqual(hasher(0), dut.GetHashCode());\r
- dut.Add(3);\r
- Assert.AreEqual(hasher(1, 3), dut.GetHashCode());\r
- dut.Add(7);\r
- Assert.AreEqual(hasher(2, 7, 3), dut.GetHashCode());\r
- }\r
-\r
-\r
- [Test]\r
- public void EqualHashButDifferent()\r
- {\r
- dit.Add(2);dit.Add(1);\r
- dat.Add(3);dat.Add(0);\r
- Assert.AreEqual(dit.GetHashCode(), dat.GetHashCode());\r
- Assert.IsFalse(dit.Equals(dat));\r
- }\r
-\r
-\r
- [Test]\r
- public void Normal()\r
- {\r
- dit.Add(3);\r
- dit.Add(7);\r
- dat.Add(3);\r
- Assert.IsFalse(dit.Equals(dat));\r
- Assert.IsFalse(dat.Equals(dit));\r
- dat.Add(7);\r
- Assert.IsTrue(dit.Equals(dat));\r
- Assert.IsTrue(dat.Equals(dit));\r
- }\r
-\r
-\r
- [Test]\r
- public void WrongOrder()\r
- {\r
- dit.Add(3);\r
- dut.Add(3);\r
- Assert.IsTrue(dit.Equals(dut));\r
- Assert.IsTrue(dut.Equals(dit));\r
- dit.Add(7);\r
- dut.Add(7);\r
- Assert.IsTrue(dit.Equals(dut));\r
- Assert.IsTrue(dut.Equals(dit));\r
- }\r
-\r
-\r
- [Test]\r
- public void Reflexive()\r
- {\r
- Assert.IsTrue(dit.Equals(dit));\r
- dit.Add(3);\r
- Assert.IsTrue(dit.Equals(dit));\r
- dit.Add(7);\r
- Assert.IsTrue(dit.Equals(dit));\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose()\r
- {\r
- dit = null;\r
- dat = null;\r
- dut = null;\r
- }\r
- }\r
-\r
-\r
-\r
- [TestFixture]\r
- public class MultiLevelUnorderedOfUnOrdered\r
- {\r
- private ICollection<int> dit, dat, dut;\r
-\r
- private ICollection<ICollection<int>> Dit, Dat, Dut;\r
-\r
-\r
- [SetUp]\r
- public void Init()\r
- {\r
- dit = new LinkedList<int>();\r
- dat = new LinkedList<int>();\r
- dut = new LinkedList<int>();\r
- dit.Add(2);dit.Add(1);\r
- dat.Add(1);dat.Add(2);\r
- dut.Add(3);\r
- Dit = new LinkedList<ICollection<int>>();\r
- Dat = new LinkedList<ICollection<int>>();\r
- Dut = new LinkedList<ICollection<int>>();\r
- }\r
-\r
-\r
- [Test]\r
- public void Check()\r
- {\r
- Assert.IsTrue(dit.Equals(dat));\r
- Assert.IsFalse(dit.Equals(dut));\r
- }\r
-\r
-\r
- [Test]\r
- public void Multi()\r
- {\r
- Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
- Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
- Assert.IsTrue(Dit.Equals(Dat));\r
- Assert.IsFalse(Dit.Equals(Dut));\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose()\r
- {\r
- dit = dat = dut = null;\r
- Dit = Dat = Dut = null;\r
- }\r
- }\r
-\r
-\r
-\r
- [TestFixture]\r
- public class MultiLevelOrderedOfUnOrdered\r
- {\r
- private ICollection<int> dit, dat, dut;\r
-\r
- private ISequenced<ICollection<int>> Dit, Dat, Dut;\r
-\r
-\r
- [SetUp]\r
- public void Init()\r
- {\r
- dit = new LinkedList<int>();\r
- dat = new LinkedList<int>();\r
- dut = new LinkedList<int>();\r
- dit.Add(2);dit.Add(1);\r
- dat.Add(1);dat.Add(2);\r
- dut.Add(3);\r
- Dit = new LinkedList<ICollection<int>>();\r
- Dat = new LinkedList<ICollection<int>>();\r
- Dut = new LinkedList<ICollection<int>>();\r
- }\r
-\r
-\r
- [Test]\r
- public void Check()\r
- {\r
- Assert.IsTrue(dit.Equals(dat));\r
- Assert.IsFalse(dit.Equals(dut));\r
- }\r
-\r
-\r
- [Test]\r
- public void Multi()\r
- {\r
- Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
- Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
- Dut.Add(dit);Dut.Add(dut);Dut.Add(dat);\r
- Assert.IsFalse(Dit.Equals(Dat));\r
- Assert.IsTrue(Dit.Equals(Dut));\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose()\r
- {\r
- dit = dat = dut = null;\r
- Dit = Dat = Dut = null;\r
- }\r
- }\r
-\r
-\r
-\r
- [TestFixture]\r
- public class MultiLevelUnOrderedOfOrdered\r
- {\r
- private ISequenced<int> dit, dat, dut, dot;\r
-\r
- private ICollection<ISequenced<int>> Dit, Dat, Dut, Dot;\r
-\r
-\r
- [SetUp]\r
- public void Init()\r
- {\r
- dit = new LinkedList<int>();\r
- dat = new LinkedList<int>();\r
- dut = new LinkedList<int>();\r
- dot = new LinkedList<int>();\r
- dit.Add(2);dit.Add(1);\r
- dat.Add(1);dat.Add(2);\r
- dut.Add(3);\r
- dot.Add(2);dot.Add(1);\r
- Dit = new LinkedList<ISequenced<int>>();\r
- Dat = new LinkedList<ISequenced<int>>();\r
- Dut = new LinkedList<ISequenced<int>>();\r
- Dot = new LinkedList<ISequenced<int>>();\r
- }\r
-\r
-\r
- [Test]\r
- public void Check()\r
- {\r
- Assert.IsFalse(dit.Equals(dat));\r
- Assert.IsTrue(dit.Equals(dot));\r
- Assert.IsFalse(dit.Equals(dut));\r
- }\r
-\r
-\r
- [Test]\r
- public void Multi()\r
- {\r
- Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
- Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
- Dut.Add(dot);Dut.Add(dut);Dut.Add(dit);\r
- Dot.Add(dit);Dot.Add(dit);Dot.Add(dut);\r
- Assert.IsTrue(Dit.Equals(Dut));\r
- Assert.IsFalse(Dit.Equals(Dat));\r
- Assert.IsTrue(Dit.Equals(Dot));\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose()\r
- {\r
- dit = dat = dut = dot = null;\r
- Dit = Dat = Dut = Dot = null;\r
- }\r
- }\r
-\r
-\r
-\r
- [TestFixture]\r
- public class MultiLevelOrderedOfOrdered\r
- {\r
- private ISequenced<int> dit, dat, dut, dot;\r
-\r
- private ISequenced<ISequenced<int>> Dit, Dat, Dut, Dot;\r
-\r
-\r
- [SetUp]\r
- public void Init()\r
- {\r
- dit = new LinkedList<int>();\r
- dat = new LinkedList<int>();\r
- dut = new LinkedList<int>();\r
- dot = new LinkedList<int>();\r
- dit.Add(2);dit.Add(1);\r
- dat.Add(1);dat.Add(2);\r
- dut.Add(3);\r
- dot.Add(2);dot.Add(1);\r
- Dit = new LinkedList<ISequenced<int>>();\r
- Dat = new LinkedList<ISequenced<int>>();\r
- Dut = new LinkedList<ISequenced<int>>();\r
- Dot = new LinkedList<ISequenced<int>>();\r
- }\r
-\r
-\r
- [Test]\r
- public void Check()\r
- {\r
- Assert.IsFalse(dit.Equals(dat));\r
- Assert.IsTrue(dit.Equals(dot));\r
- Assert.IsFalse(dit.Equals(dut));\r
- }\r
-\r
-\r
- [Test]\r
- public void Multi()\r
- {\r
- Dit.Add(dit);Dit.Add(dut);Dit.Add(dit);\r
- Dat.Add(dut);Dat.Add(dit);Dat.Add(dat);\r
- Dut.Add(dot);Dut.Add(dut);Dut.Add(dit);\r
- Dot.Add(dit);Dot.Add(dit);Dot.Add(dut);\r
- Assert.IsTrue(Dit.Equals(Dut));\r
- Assert.IsFalse(Dit.Equals(Dat));\r
- Assert.IsFalse(Dit.Equals(Dot));\r
- }\r
-\r
-\r
- [TearDown]\r
- public void Dispose()\r
- {\r
- dit = dat = dut = dot = null;\r
- Dit = Dat = Dut = Dot = null;\r
- }\r
- }\r
- }\r
-}\r
-#endif\r
+ [TestFixture]\r
+ public class MultiLevelOrderedOfUnOrdered\r
+ {\r
+ private ICollection<int> dit, dat, dut;\r
+\r
+ private ISequenced<ICollection<int>> Dit, Dat, Dut;\r
+\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ dit = new LinkedList<int>();\r
+ dat = new LinkedList<int>();\r
+ dut = new LinkedList<int>();\r
+ dit.Add(2); dit.Add(1);\r
+ dat.Add(1); dat.Add(2);\r
+ dut.Add(3);\r
+ Dit = new LinkedList<ICollection<int>>();\r
+ Dat = new LinkedList<ICollection<int>>();\r
+ Dut = new LinkedList<ICollection<int>>();\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Check()\r
+ {\r
+ Assert.IsTrue(dit.UnsequencedEquals(dat));\r
+ Assert.IsFalse(dit.UnsequencedEquals(dut));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Multi()\r
+ {\r
+ Dit.Add(dit); Dit.Add(dut); Dit.Add(dit);\r
+ Dat.Add(dut); Dat.Add(dit); Dat.Add(dat);\r
+ Dut.Add(dit); Dut.Add(dut); Dut.Add(dat);\r
+ Assert.IsFalse(Dit.SequencedEquals(Dat));\r
+ Assert.IsTrue(Dit.SequencedEquals(Dut));\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose()\r
+ {\r
+ dit = dat = dut = null;\r
+ Dit = Dat = Dut = null;\r
+ }\r
+ }\r
+\r
+\r
+\r
+ [TestFixture]\r
+ public class MultiLevelUnOrderedOfOrdered\r
+ {\r
+ private ISequenced<int> dit, dat, dut, dot;\r
+\r
+ private ICollection<ISequenced<int>> Dit, Dat, Dut, Dot;\r
+\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ dit = new LinkedList<int>();\r
+ dat = new LinkedList<int>();\r
+ dut = new LinkedList<int>();\r
+ dot = new LinkedList<int>();\r
+ dit.Add(2); dit.Add(1);\r
+ dat.Add(1); dat.Add(2);\r
+ dut.Add(3);\r
+ dot.Add(2); dot.Add(1);\r
+ Dit = new LinkedList<ISequenced<int>>();\r
+ Dat = new LinkedList<ISequenced<int>>();\r
+ Dut = new LinkedList<ISequenced<int>>();\r
+ Dot = new LinkedList<ISequenced<int>>();\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Check()\r
+ {\r
+ Assert.IsFalse(dit.SequencedEquals(dat));\r
+ Assert.IsTrue(dit.SequencedEquals(dot));\r
+ Assert.IsFalse(dit.SequencedEquals(dut));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Multi()\r
+ {\r
+ Dit.Add(dit); Dit.Add(dut); Dit.Add(dit);\r
+ Dat.Add(dut); Dat.Add(dit); Dat.Add(dat);\r
+ Dut.Add(dot); Dut.Add(dut); Dut.Add(dit);\r
+ Dot.Add(dit); Dot.Add(dit); Dot.Add(dut);\r
+ Assert.IsTrue(Dit.UnsequencedEquals(Dut));\r
+ Assert.IsFalse(Dit.UnsequencedEquals(Dat));\r
+ Assert.IsTrue(Dit.UnsequencedEquals(Dot));\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose()\r
+ {\r
+ dit = dat = dut = dot = null;\r
+ Dit = Dat = Dut = Dot = null;\r
+ }\r
+ }\r
+\r
+\r
+\r
+ [TestFixture]\r
+ public class MultiLevelOrderedOfOrdered\r
+ {\r
+ private ISequenced<int> dit, dat, dut, dot;\r
+\r
+ private ISequenced<ISequenced<int>> Dit, Dat, Dut, Dot;\r
+\r
+\r
+ [SetUp]\r
+ public void Init()\r
+ {\r
+ dit = new LinkedList<int>();\r
+ dat = new LinkedList<int>();\r
+ dut = new LinkedList<int>();\r
+ dot = new LinkedList<int>();\r
+ dit.Add(2); dit.Add(1);\r
+ dat.Add(1); dat.Add(2);\r
+ dut.Add(3);\r
+ dot.Add(2); dot.Add(1);\r
+ Dit = new LinkedList<ISequenced<int>>();\r
+ Dat = new LinkedList<ISequenced<int>>();\r
+ Dut = new LinkedList<ISequenced<int>>();\r
+ Dot = new LinkedList<ISequenced<int>>();\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Check()\r
+ {\r
+ Assert.IsFalse(dit.SequencedEquals(dat));\r
+ Assert.IsTrue(dit.SequencedEquals(dot));\r
+ Assert.IsFalse(dit.SequencedEquals(dut));\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void Multi()\r
+ {\r
+ Dit.Add(dit); Dit.Add(dut); Dit.Add(dit);\r
+ Dat.Add(dut); Dat.Add(dit); Dat.Add(dat);\r
+ Dut.Add(dot); Dut.Add(dut); Dut.Add(dit);\r
+ Dot.Add(dit); Dot.Add(dit); Dot.Add(dut);\r
+ Assert.IsTrue(Dit.SequencedEquals(Dut));\r
+ Assert.IsFalse(Dit.SequencedEquals(Dat));\r
+ Assert.IsFalse(Dit.SequencedEquals(Dot));\r
+ }\r
+\r
+\r
+ [TearDown]\r
+ public void Dispose()\r
+ {\r
+ dit = dat = dut = dot = null;\r
+ Dit = Dat = Dut = Dot = null;\r
+ }\r
+ }\r
+ }\r
+}
\ No newline at end of file
projects / mono.git / blobdiff