orderedbagtests.cs

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

        [Test]
        public void Difference()
        {
            OrderedBag<int> bagOdds = new OrderedBag<int>(new int[] { 1, 1, 1, 3, 3, 3, 5, 7, 7, 9, 11, 11, 13, 15, 17, 17, 19 });
            OrderedBag<int> bagDigits = new OrderedBag<int>(new int[] { 1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 7, 7, 7, 7, 7, 7, 8, 9 });
            OrderedBag<int> bag1, bag2, bag3;

            // Algorithms work different depending on sizes, so try both ways.
            bag1 = bagOdds.Clone(); bag2 = bagDigits.Clone();
            bag1.DifferenceWith(bag2);
            InterfaceTests.TestReadWriteCollectionGeneric(bag1, new int[] { 1, 1, 11, 11, 13, 15, 17, 17, 19 }, true);

            bag1 = bagOdds.Clone(); bag2 = bagDigits.Clone();
            bag2.DifferenceWith(bag1);
            InterfaceTests.TestReadWriteCollectionGeneric(bag2, new int[] { 2, 2, 4, 5, 6, 7, 7, 7, 7, 8 }, true);

            bag1 = bagOdds.Clone(); bag2 = bagDigits.Clone();
            bag3 = bag1.Difference(bag2);
            InterfaceTests.TestReadWriteCollectionGeneric(bag3, new int[] { 1, 1, 11, 11, 13, 15, 17, 17, 19 }, true);

            bag1 = bagOdds.Clone(); bag2 = bagDigits.Clone();
            bag3 = bag2.Difference(bag1);
            InterfaceTests.TestReadWriteCollectionGeneric(bag3, new int[] { 2, 2, 4, 5, 6, 7, 7, 7, 7, 8 }, true);

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

            bag1 = bagDigits.Clone();
            bag3 = bag1.Difference(bag1);
            Assert.AreEqual(0, bag3.Count);
        }

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

            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()
        {
            OrderedBag<int> bag1 = new OrderedBag<int>(new int[] { 11, 6, 9, 7, 1, 11, 9, 3, 7, 8, 7 });
            OrderedBag<int> bag2 = new OrderedBag<int>();
            OrderedBag<int> bag3 = new OrderedBag<int>();
            OrderedBag<int> bag4 = new OrderedBag<int>(new int[] { 9, 11, 1, 3, 7, 6, 7, 8, 9, 14, 7 });
            OrderedBag<int> bag5 = new OrderedBag<int>(new int[] { 11, 7, 6, 9, 8, 3, 7, 1, 11, 9, 3 });
            OrderedBag<int> bag6 = new OrderedBag<int>(new int[] { 11, 1, 9, 3, 6, 7, 8, 7, 10, 7, 11, 9 });
            OrderedBag<int> bag7 = new OrderedBag<int>(new int[] { 9, 7, 1, 9, 11, 8, 3, 7, 7, 6, 11 });

            Assert.IsTrue(bag1.IsEqualTo(bag1));
            Assert.IsTrue(bag2.IsEqualTo(bag2));

            Assert.IsTrue(bag2.IsEqualTo(bag3));
            Assert.IsTrue(bag3.IsEqualTo(bag2));

            Assert.IsTrue(bag1.IsEqualTo(bag7));
            Assert.IsTrue(bag7.IsEqualTo(bag1));

            Assert.IsFalse(bag1.IsEqualTo(bag2));
            Assert.IsFalse(bag2.IsEqualTo(bag1));

            Assert.IsFalse(bag1.IsEqualTo(bag4));
            Assert.IsFalse(bag4.IsEqualTo(bag1));

            Assert.IsFalse(bag1.IsEqualTo(bag5));
            Assert.IsFalse(bag5.IsEqualTo(bag1));

            Assert.IsFalse(bag1.IsEqualTo(bag6));
            Assert.IsFalse(bag6.IsEqualTo(bag1));

            Assert.IsFalse(bag5.IsEqualTo(bag6));
            Assert.IsFalse(bag6.IsEqualTo(bag5));

            Assert.IsFalse(bag5.IsEqualTo(bag7));
            Assert.IsFalse(bag7.IsEqualTo(bag5));
        }

        [Test]
        public void Clone()
        {
            OrderedBag<int> bag1 = new OrderedBag<int>(new int[] { 1, 7, 9, 11, 7, 13, 15, -17, 19, -21, 1 });
            OrderedBag<int> bag2, bag3;

            bag2 = bag1.Clone();
            bag3 = (OrderedBag<int>)((ICloneable)bag1).Clone();

            Assert.IsFalse(bag2 == bag1);
            Assert.IsFalse(bag3 == bag1);

            // Modify bag1, make sure bag2, bag3 don't change.
            bag1.Remove(9);
            bag1.Remove(-17);
            bag1.Add(8);

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

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

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

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

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

            OrderedBag<string> bag1 = new OrderedBag<string>(new string[] { "foo", "Bar" }, StringComparer.InvariantCulture);
            OrderedBag<string> bag2 = new OrderedBag<string>(new string[] { "bada", "bing" }, StringComparer.InvariantCulture);
            bag1.Difference(bag2);
        }


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

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

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

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

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

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

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

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

        // Check a View to make sure it has the right stuff.
        private void CheckView<T>(OrderedBag<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]);
                int index = view.IndexOf(items[i]);
                Assert.IsTrue(i == index || index < i && object.Equals(items[index], items[i]));
                index = view.LastIndexOf(items[i]);
                Assert.IsTrue(i == index || index > i && object.Equals(items[index], 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);
            Assert.IsTrue(view.LastIndexOf(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);
        }

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

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

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

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

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

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

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

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

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

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

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

            Assert.IsFalse(bag1.Range(3, true, 8, false).Remove(9));
            Assert.IsTrue(bag1.Contains(9));
            bag1.Range(3, true, 8, false).Add(7);