orderedsettests.cs

C#写的类似于STL的集合类,首先是C#编写,可以用于.net变程.

            Assert.IsFalse(set1.Range(3, true, 8, false).Remove(9));
            Assert.IsTrue(set1.Contains(9));
            Assert.IsFalse(set1.Range(3, true, 8, false).Add(7));
            Assert.IsTrue(set1.Contains(8));
            Assert.IsTrue(set1.Range(3, true, 11, false).Reversed().Remove(4));
            Assert.IsFalse(set1.Contains(4));
        }


        // Simple class for testing cloning.
        class MyInt : ICloneable
        {
            public int value;
            public MyInt(int value)
            {
                this.value = value;
            }

            public object Clone()
            {
                return new MyInt(value);
            }

            public override bool Equals(object obj)
            {
                return (obj is MyInt && ((MyInt)obj).value == value);
            }

            public override int GetHashCode()
            {
                return value.GetHashCode();
            }

            public override string ToString()
            {
                return value.ToString();
            }
        }

        void CompareClones<T>(OrderedSet<T> s1, OrderedSet<T> s2)
        {
            IEnumerator<T> e1 = s1.GetEnumerator();
            IEnumerator<T> e2 = s2.GetEnumerator();

            // Check that the sets are equal, but not reference equals (e.g., have been cloned).
            while (e1.MoveNext()) {
                e2.MoveNext();
                if (e1.Current == null) {
                    Assert.IsNull(e2.Current);
                }
                else {
                    Assert.IsTrue(e1.Current.Equals(e2.Current));
                    Assert.IsFalse(object.ReferenceEquals(e1.Current, e2.Current));
                }
            }
        }

        [Test]
        public void CloneContents()
        {
            OrderedSet<MyInt> set1 = new OrderedSet<MyInt>(
                delegate(MyInt v1, MyInt v2) { 
                    if (v1 == null) {
                        return (v2 == null) ? 0 : -1;
                    }
                    else if (v2 == null)
                        return 1;
                    else
                        return v2.value.CompareTo(v1.value); 
                });

            set1.Add(new MyInt(143));
            set1.Add(new MyInt(2));
            set1.Add(new MyInt(9));
            set1.Add(null);
            set1.Add(new MyInt(14));
            set1.Add(new MyInt(111));
            OrderedSet<MyInt> set2 = set1.CloneContents();
            CompareClones(set1, set2);

            OrderedSet<int> set3 = new OrderedSet<int>(new int[] { 144, 5, 23, 1, 8 });
            OrderedSet<int> set4 = set3.CloneContents();
            CompareClones(set3, set4);

            Comparison<UtilTests.CloneableStruct> comparison = delegate(UtilTests.CloneableStruct s1, UtilTests.CloneableStruct s2) {
                return s1.value.CompareTo(s2.value);
            };
            OrderedSet<UtilTests.CloneableStruct> set5 = new OrderedSet<UtilTests.CloneableStruct>(comparison);
            set5.Add(new UtilTests.CloneableStruct(143));
            set5.Add(new UtilTests.CloneableStruct(5));
            set5.Add(new UtilTests.CloneableStruct(23));
            set5.Add(new UtilTests.CloneableStruct(1));
            set5.Add(new UtilTests.CloneableStruct(8));
            OrderedSet<UtilTests.CloneableStruct> set6 = set5.CloneContents();

            Assert.AreEqual(set5.Count, set6.Count);

            // Check that the sets are equal, but not identical (e.g., have been cloned via ICloneable).
            IEnumerator<UtilTests.CloneableStruct> e1 = set5.GetEnumerator();
            IEnumerator<UtilTests.CloneableStruct> e2 = set6.GetEnumerator();

            // Check that the sets are equal, but not reference equals (e.g., have been cloned).
            while (e1.MoveNext()) {
                e2.MoveNext();
                Assert.IsTrue(e1.Current.Equals(e2.Current));
                Assert.IsFalse(e1.Current.Identical(e2.Current));
            }


        }

        class NotCloneable { }

        [Test, ExpectedException(typeof(InvalidOperationException))]
        public void CantCloneContents()
        {
            OrderedSet<NotCloneable> set1 = new OrderedSet<NotCloneable>();

            set1.Add(new NotCloneable());
            set1.Add(new NotCloneable());

            OrderedSet<NotCloneable> set2 = set1.CloneContents();
        }

        [Test]
        public void CustomComparison()
        {
            Comparison<int> myOrdering = ComparersTests.CompareOddEven;

            OrderedSet<int> set1 = new OrderedSet<int>(myOrdering);
            set1.Add(8);
            set1.Add(12);
            set1.Add(9);
            set1.Add(3);
            InterfaceTests.TestReadWriteCollectionGeneric<int>(set1, new int[] { 3, 9, 8, 12 }, true, null);
        }

        [Test]
        public void CustomIComparer()
        {
            IComparer<int> myComparer = new GOddEvenComparer();

            OrderedSet<int> set1 = new OrderedSet<int>(myComparer);
            set1.Add(8);
            set1.Add(12);
            set1.Add(9);
            set1.Add(3);
            InterfaceTests.TestReadWriteCollectionGeneric<int>(set1, new int[] { 3, 9, 8, 12 }, true, null);
        }

        [Test]
        public void ComparerProperty()
        {
            IComparer<int> comparer1 = new GOddEvenComparer();
            OrderedSet<int> set1 = new OrderedSet<int>(comparer1);
            Assert.AreSame(comparer1, set1.Comparer);
            OrderedSet<decimal> set2 = new OrderedSet<decimal>();
            Assert.AreSame(Comparer<decimal>.Default, set2.Comparer);
            OrderedSet<string> set3 = new OrderedSet<string>(StringComparer.OrdinalIgnoreCase);
            Assert.AreSame(StringComparer.OrdinalIgnoreCase, set3.Comparer);

            Comparison<int> comparison1 = ComparersTests.CompareOddEven;
            OrderedSet<int> set4 = new OrderedSet<int>(comparison1);
            OrderedSet<int> set5 = new OrderedSet<int>(comparison1);
            Assert.AreEqual(set4.Comparer, set5.Comparer);
            Assert.IsFalse(set4.Comparer == set5.Comparer);
            Assert.IsFalse(object.Equals(set4.Comparer, set1.Comparer));
            Assert.IsFalse(object.Equals(set4.Comparer, Comparer<int>.Default));
            Assert.IsTrue(set4.Comparer.Compare(7, 6) < 0);
        }


        [Test]
        public void Initialize()
        {
            Comparison<int> myOrdering = ComparersTests.CompareOddEven;
            IComparer<int> myComparer = new GOddEvenComparer();
            List<int> list = new List<int>(new int[] { 12, 3, 9, 8, 9, 3 });
            OrderedSet<int> set1 = new OrderedSet<int>(list);
            OrderedSet<int> set2 = new OrderedSet<int>(list, myOrdering);
            OrderedSet<int> set3 = new OrderedSet<int>(list, myComparer);

            InterfaceTests.TestReadWriteCollectionGeneric<int>(set1, new int[] { 3, 8, 9, 12 }, true, null);
            InterfaceTests.TestReadWriteCollectionGeneric<int>(set2, new int[] { 3, 9, 8, 12 }, true, null);
            InterfaceTests.TestReadWriteCollectionGeneric<int>(set3, new int[] { 3, 9, 8, 12 }, true, null);
        }


        [Test]
        public void Smallest()
        {
            OrderedSet<string> set1 = new OrderedSet<string>(
                new string[] { "foo", null, "Foo", "Eric", "FOO", "eric", "bar" }, StringComparer.InvariantCultureIgnoreCase);

            string s;

            Assert.AreEqual(4, set1.Count);

            s = set1.GetFirst();
            Assert.IsNull(s);
            s = set1.RemoveFirst();
            Assert.IsNull(s);
            Assert.AreEqual(3, set1.Count);

            s = set1.GetFirst();
            Assert.AreEqual("bar", s);
            s = set1.RemoveFirst();
            Assert.AreEqual("bar", s);
            Assert.AreEqual(2, set1.Count);

            s = set1.GetFirst();
            Assert.AreEqual("eric", s);
            s = set1.RemoveFirst();
            Assert.AreEqual("eric", s);
            Assert.AreEqual(1, set1.Count);

            s = set1.GetFirst();
            Assert.AreEqual("FOO", s);
            s = set1.RemoveFirst();
            Assert.AreEqual("FOO", s);
            Assert.AreEqual(0, set1.Count);
        }

        [Test]
        public void Largest()
        {
            OrderedSet<string> set1 = new OrderedSet<string>(
                new string[] { "foo", null, "Foo", "Eric", "FOO", "eric", "bar" }, StringComparer.InvariantCultureIgnoreCase);

            string s;

            Assert.AreEqual(4, set1.Count);

            s = set1.GetLast();
            Assert.AreEqual("FOO", s);
            s = set1.RemoveLast();
            Assert.AreEqual("FOO", s);
            Assert.AreEqual(3, set1.Count);

            s = set1.GetLast();
            Assert.AreEqual("eric", s);
            s = set1.RemoveLast();
            Assert.AreEqual("eric", s);
            Assert.AreEqual(2, set1.Count);

            s = set1.GetLast();
            Assert.AreEqual("bar", s);
            s = set1.RemoveLast();
            Assert.AreEqual("bar", s);
            Assert.AreEqual(1, set1.Count);

            s = set1.GetLast();
            Assert.IsNull(s);
            s = set1.RemoveLast();
            Assert.IsNull(s);
            Assert.AreEqual(0, set1.Count);
        }

        [Test]
        public void SmallestLargestException()
        {
            OrderedSet<string> set1 = new OrderedSet<string>(StringComparer.InvariantCultureIgnoreCase);

            try {
                set1.GetFirst();
                Assert.Fail("Should have thrown exception");
            }
            catch (Exception e) {
                Assert.IsTrue(e is InvalidOperationException);
            }

            try {
                set1.GetLast();
                Assert.Fail("Should have thrown exception");
            }
            catch (Exception e) {
                Assert.IsTrue(e is InvalidOperationException);
            }

            try {
                set1.RemoveFirst();
                Assert.Fail("Should have thrown exception");
            }
            catch (Exception e) {
                Assert.IsTrue(e is InvalidOperationException);
            }

            try {
                set1.RemoveLast();
                Assert.Fail("Should have thrown exception");
            }
            catch (Exception e) {
                Assert.IsTrue(e is InvalidOperationException);
            }
        }

        [Test]
        public void SerializeStrings()
        {
            OrderedSet<string> d = new OrderedSet<string>(StringComparer.InvariantCultureIgnoreCase);

            d.Add("foo");
            d.Add("WORLD");
            d.Add("Hello");
            d.Add("eLVIs");
            d.Add("elvis");
            d.Add(null);
            d.Add("cool");
            d.AddMany(new string[] { "1", "2", "3", "4", "5", "6" });
            d.AddMany(new string[] { "7", "8", "9", "10", "11", "12" });

            OrderedSet<string> result = (OrderedSet<string>)InterfaceTests.SerializeRoundTrip(d);

            InterfaceTests.TestReadWriteCollectionGeneric<string>((ICollection<string>)result, new string[] { null, "1", "10", "11", "12", "2", "3", "4", "5", "6", "7", "8", "9", "cool", "elvis", "foo", "hello", "world" }, true, StringComparer.InvariantCultureIgnoreCase.Equals);

        }


    }
}