orderedsettests.cs

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

            set3 = set2.Difference(set1);
            InterfaceTests.TestReadWriteCollectionGeneric(set3, new int[] { 2, 4, 6, 8 }, true, null);

            // Make sure intersection with itself works.
            set1 = setDigits.Clone();
            set1.DifferenceWith(set1);
            Assert.AreEqual(0, set1.Count);

            set1 = setDigits.Clone();
            set3 = set1.Difference(set1);
            Assert.AreEqual(0, set3.Count);
        }

        [Test]
        public void Subset()
        {
            OrderedSet<int> set1 = new OrderedSet<int>(new int[] { 1, 3, 6, 7, 8, 9, 10 });
            OrderedSet<int> set2 = new OrderedSet<int>();
            OrderedSet<int> set3 = new OrderedSet<int>(new int[] { 3, 8, 9 });
            OrderedSet<int> set4 = new OrderedSet<int>(new int[] { 3, 8, 9 });
            OrderedSet<int> set5 = new OrderedSet<int>(new int[] { 1, 2, 6, 8, 9, 10 });

            Assert.IsTrue(set1.IsSupersetOf(set2));
            Assert.IsTrue(set2.IsSubsetOf(set1));
            Assert.IsTrue(set1.IsProperSupersetOf(set2));
            Assert.IsTrue(set2.IsProperSubsetOf(set1));

            Assert.IsTrue(set1.IsSupersetOf(set3));
            Assert.IsTrue(set3.IsSubsetOf(set1));
            Assert.IsTrue(set1.IsProperSupersetOf(set3));
            Assert.IsTrue(set3.IsProperSubsetOf(set1));

            Assert.IsFalse(set3.IsSupersetOf(set1));
            Assert.IsFalse(set1.IsSubsetOf(set3));
            Assert.IsFalse(set3.IsProperSupersetOf(set1));
            Assert.IsFalse(set1.IsProperSubsetOf(set3));

            Assert.IsFalse(set1.IsSupersetOf(set5));
            Assert.IsFalse(set5.IsSupersetOf(set1));
            Assert.IsFalse(set1.IsSubsetOf(set5));
            Assert.IsFalse(set5.IsSubsetOf(set1));
            Assert.IsFalse(set1.IsProperSupersetOf(set5));
            Assert.IsFalse(set5.IsProperSupersetOf(set1));
            Assert.IsFalse(set1.IsProperSubsetOf(set5));
            Assert.IsFalse(set5.IsProperSubsetOf(set1));

            Assert.IsTrue(set3.IsSupersetOf(set4));
            Assert.IsTrue(set3.IsSubsetOf(set4));
            Assert.IsFalse(set3.IsProperSupersetOf(set4));
            Assert.IsFalse(set3.IsProperSubsetOf(set4));

            Assert.IsTrue(set1.IsSupersetOf(set1));
            Assert.IsTrue(set1.IsSubsetOf(set1));
            Assert.IsFalse(set1.IsProperSupersetOf(set1));
            Assert.IsFalse(set1.IsProperSubsetOf(set1));
        }

        [Test]
        public void IsEqualTo()
        {
            OrderedSet<int> set1 = new OrderedSet<int>(new int[] { 6, 7, 1, 11, 9, 3, 8 });
            OrderedSet<int> set2 = new OrderedSet<int>();
            OrderedSet<int> set3 = new OrderedSet<int>();
            OrderedSet<int> set4 = new OrderedSet<int>(new int[] { 9, 11, 1, 3, 6, 7, 8, 14 });
            OrderedSet<int> set5 = new OrderedSet<int>(new int[] { 3, 6, 7, 11, 14, 8, 9 });
            OrderedSet<int> set6 = new OrderedSet<int>(new int[] { 1, 3, 6, 7, 8, 10, 11 });
            OrderedSet<int> set7 = new OrderedSet<int>(new int[] { 9, 1, 8, 3, 7, 6, 11 });

            Assert.IsTrue(set1.IsEqualTo(set1));
            Assert.IsTrue(set2.IsEqualTo(set2));

            Assert.IsTrue(set2.IsEqualTo(set3));
            Assert.IsTrue(set3.IsEqualTo(set2));

            Assert.IsTrue(set1.IsEqualTo(set7));
            Assert.IsTrue(set7.IsEqualTo(set1));

            Assert.IsFalse(set1.IsEqualTo(set2));
            Assert.IsFalse(set2.IsEqualTo(set1));

            Assert.IsFalse(set1.IsEqualTo(set4));
            Assert.IsFalse(set4.IsEqualTo(set1));

            Assert.IsFalse(set1.IsEqualTo(set5));
            Assert.IsFalse(set5.IsEqualTo(set1));

            Assert.IsFalse(set1.IsEqualTo(set6));
            Assert.IsFalse(set6.IsEqualTo(set1));

            Assert.IsFalse(set5.IsEqualTo(set6));
            Assert.IsFalse(set6.IsEqualTo(set5));

            Assert.IsFalse(set5.IsEqualTo(set7));
            Assert.IsFalse(set7.IsEqualTo(set5));
        }

        [Test]
        public void Clone()
        {
            OrderedSet<int> set1 = new OrderedSet<int>(new int[] { 1, 7, 9, 11, 13, 15, -17, 19, -21 });
            OrderedSet<int> set2, set3;

            set2 = set1.Clone();
            set3 = (OrderedSet<int>)((ICloneable)set1).Clone();

            Assert.IsFalse(set2 == set1);
            Assert.IsFalse(set3 == set1);

            // Modify set1, make sure set2, set3 don't change.
            set1.Remove(9);
            set1.Remove(-17);
            set1.Add(8);

            InterfaceTests.TestReadWriteCollectionGeneric(set2, new int[] { -21, -17, 1, 7, 9, 11, 13, 15, 19 }, true, null);
            InterfaceTests.TestReadWriteCollectionGeneric(set3, new int[] { -21, -17, 1, 7, 9, 11, 13, 15, 19 }, true, null);
        }

        [Test, ExpectedException(typeof(InvalidOperationException))]
        public void InconsistentComparisons1()
        {
            OrderedSet<int> setOdds = new OrderedSet<int>(new int[] { 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25 });
            OrderedSet<int> setDigits = new OrderedSet<int>(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, ComparersTests.CompareOddEven);
            setOdds.UnionWith(setDigits);
        }

        [Test, ExpectedException(typeof(InvalidOperationException))]
        public void InconsistentComparisons2()
        {
            OrderedSet<int> setOdds = new OrderedSet<int>(new int[] { 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25 });
            OrderedSet<int> setDigits = new OrderedSet<int>(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, new GOddEvenComparer());
            setOdds.SymmetricDifferenceWith(setDigits);
        }

        [Test, ExpectedException(typeof(InvalidOperationException))]
        public void InconsistentComparisons3()
        {
            OrderedSet<string> set1 = new OrderedSet<string>(new string[] { "foo", "Bar" }, StringComparer.CurrentCulture);
            OrderedSet<string> set2 = new OrderedSet<string>(new string[] { "bada", "bing"}, StringComparer.InvariantCulture);
            set1.Intersection(set2);
        }

        [Test]
        public void ConsistentComparisons()
        {
            OrderedSet<int> setOdds = new OrderedSet<int>(new int[] { 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25 }, ComparersTests.CompareOddEven);
            OrderedSet<int> setDigits = new OrderedSet<int>(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, ComparersTests.CompareOddEven);
            setOdds.UnionWith(setDigits);

            OrderedSet<string> set1 = new OrderedSet<string>(new string[] { "foo", "Bar" }, StringComparer.InvariantCulture);
            OrderedSet<string> set2 = new OrderedSet<string>(new string[] { "bada", "bing" }, StringComparer.InvariantCulture);
            set1.Difference(set2);
        }


        [Test, ExpectedException(typeof(InvalidOperationException))]
        public void NotComparable1()
        {
            OrderedSet<UncomparableClass1> set1 = new OrderedSet<UncomparableClass1>();
        }

        [Test, ExpectedException(typeof(InvalidOperationException))]
        public void NotComparable2()
        {
            OrderedSet<UncomparableClass2> set1 = new OrderedSet<UncomparableClass2>();
        }

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

            double d = 1.218034;
            for (int i = 0; i < 50; ++i) {
                set1.Add(d);
                d = d * 1.3451 - .31;
            }

            // should throw once the set is modified.
            foreach (double k in set1) {
                if (k > 3.0)
                    set1.Add(1.0);
            }
        }

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

            double d = 1.218034;
            for (int i = 0; i < 50; ++i) {
                set1.Add(d);
                d = d * 1.3451 - .31;
            }

            // should throw once the set is modified.
            foreach (double k in set1) {
                if (k > 3.0)
                    set1.Clear();
            }
        }

        // Check a View to make sure it has the right stuff.
        private void CheckView<T>(OrderedSet<T>.View view, T[] items, T nonItem)
        {
            Assert.AreEqual(items.Length, view.Count);

            T[] array = view.ToArray();      // Check ToArray
            Assert.AreEqual(items.Length, array.Length);
            for (int i = 0; i < items.Length; ++i) {
                Assert.AreEqual(items[i], array[i]);
                Assert.AreEqual(items[i], view[i]);
                Assert.AreEqual(i, view.IndexOf(items[i]));
            }

            if (items.Length > 0) {
                Assert.AreEqual(items[0], view.GetFirst());
                Assert.AreEqual(items[items.Length - 1], view.GetLast());
            }
            else {
                try {
                    view.GetFirst();
                    Assert.Fail("should throw");
                }
                catch (Exception e) {
                    Assert.IsTrue(e is InvalidOperationException);
                }

                try {
                    view.GetLast();
                    Assert.Fail("should throw");
                }
                catch (Exception e) {
                    Assert.IsTrue(e is InvalidOperationException);
                }
            }

            Assert.IsFalse(view.Contains(nonItem));
            Assert.IsTrue(view.IndexOf(nonItem) < 0);

            InterfaceTests.TestCollection<T>((ICollection)view, items, true);
            InterfaceTests.TestReadOnlyListGeneric<T>(view.AsList(), items, null);
            Array.Reverse(items);
            InterfaceTests.TestCollection<T>((ICollection)view.Reversed(), items, true);
            InterfaceTests.TestReadOnlyListGeneric<T>(view.Reversed().AsList(), items, null);
            Array.Reverse(items);
            InterfaceTests.TestReadWriteCollectionGeneric<T>((ICollection<T>)view, items, true, null);
        }

        // Check Range methods.
        [Test]
        public void Range()
        {
            OrderedSet<int> set1 = new OrderedSet<int>(new int[] { 1,3,4,6,8,9,11,14,22});

            CheckView(set1.Clone().Range(4, true, 11, false), new int[] { 4, 6, 8, 9 }, 11);
            CheckView(set1.Clone().Range(4, false, 11, false), new int[] { 6, 8, 9 }, 4);
            CheckView(set1.Clone().Range(4, false, 11, true), new int[] { 6, 8, 9, 11 }, 4);
            CheckView(set1.Clone().Range(4, true, 11, true), new int[] { 4, 6, 8, 9, 11 }, 3);
            CheckView(set1.Clone().Range(4, true, 4, false), new int[] { }, 4);
            CheckView(set1.Clone().Range(4, true, 4, true), new int[] { 4 }, 5);
            CheckView(set1.Clone().Range(11, true, 4, false), new int[] { }, 6);
            CheckView(set1.Clone().Range(11, true, 4, true), new int[] { }, 6);
            CheckView(set1.Clone().Range(0, true, 100, true), new int[] { 1, 3, 4, 6, 8, 9, 11, 14, 22 }, 0);
            CheckView(set1.Clone().Range(0, false, 100, false), new int[] { 1, 3, 4, 6, 8, 9, 11, 14, 22 }, 0);
            CheckView(set1.Clone().Range(1, true, 14, false), new int[] { 1, 3, 4, 6, 8, 9, 11 }, 14);
            CheckView(set1.Clone().Range(1, true, 15, false), new int[] { 1, 3, 4, 6, 8, 9, 11, 14 }, 22);
            CheckView(set1.Clone().Range(1, true, 14, true), new int[] { 1, 3, 4, 6, 8, 9, 11, 14 }, 22);
            CheckView(set1.Clone().Range(2, true, 15, false), new int[] { 3, 4, 6, 8, 9, 11, 14 }, 1);
            CheckView(set1.Clone().RangeFrom(9, true), new int[] { 9, 11, 14, 22 }, 8);
            CheckView(set1.Clone().RangeFrom(9, false), new int[] { 11, 14, 22 }, 9);
            CheckView(set1.Clone().RangeFrom(1, true), new int[] { 1, 3, 4, 6, 8, 9, 11, 14, 22 }, 0);
            CheckView(set1.Clone().RangeFrom(1, false), new int[] { 3, 4, 6, 8, 9, 11, 14, 22 }, 1);
            CheckView(set1.Clone().RangeFrom(100, true), new int[] { }, 1);
            CheckView(set1.Clone().RangeFrom(100, false), new int[] { }, 1);
            CheckView(set1.Clone().RangeTo(9, false), new int[] { 1, 3, 4, 6, 8 }, 9);
            CheckView(set1.Clone().RangeTo(9, true), new int[] { 1, 3, 4, 6, 8, 9 }, 11);
            CheckView(set1.Clone().RangeTo(1, false), new int[] { }, 1);
            CheckView(set1.Clone().RangeTo(0, true), new int[] { }, 1);
            CheckView(set1.Clone().RangeTo(100, false), new int[] { 1, 3, 4, 6, 8, 9, 11, 14, 22 }, 0);
            CheckView(set1.Clone().RangeTo(100, true), new int[] { 1, 3, 4, 6, 8, 9, 11, 14, 22 }, 0);
        }

        // Check Range methods.
        [Test]
        public void Reversed()
        {
            OrderedSet<int> set1 = new OrderedSet<int>(new int[] { 1, 3, 4, 6, 8, 9, 11, 14, 22 });

            CheckView(set1.Reversed(), new int[] { 22, 14, 11, 9, 8, 6, 4, 3, 1 }, 0);
        }

        [Test]
        public void ViewClear()
        {
            OrderedSet<int> set1 = new OrderedSet<int>(new int[] { 1, 3, 4, 6, 8, 9, 11, 14, 22 });

            set1.Range(6, false, 11, true).Clear();
            InterfaceTests.TestReadWriteCollectionGeneric(set1, new int[] { 1, 3, 4, 6, 14, 22 }, true, null);
        }

        [Test, ExpectedException(typeof(ArgumentException))]
        public void ViewAddException1()
        {
            OrderedSet<int> set1 = new OrderedSet<int>(new int[] { 1, 3, 4, 6, 8, 9, 11, 14, 22 });

            set1.Range(3, true, 8, false).Add(8);
        }

        [Test, ExpectedException(typeof(ArgumentException))]
        public void ViewAddException2()
        {
            OrderedSet<int> set1 = new OrderedSet<int>(new int[] { 1, 3, 4, 6, 8, 9, 11, 14, 22 });

            set1.Range(3, true, 8, false).Add(2);
        }

        [Test]
        public void ViewAddRemove()
        {
            OrderedSet<int> set1 = new OrderedSet<int>(new int[] { 1, 3, 4, 6, 8, 9, 11, 14, 22 });