algorithmstests.cs

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

                    Assert.IsTrue(comparer.Equals(coll6, coll8));
                    Assert.IsTrue(comparer.Equals(coll2, coll1));
                    Assert.IsTrue(comparer.Equals(coll3, coll3));
                    Assert.IsFalse(comparer.Equals(coll6, coll7));
                    Assert.IsFalse(comparer.Equals(coll3, coll4));

                    Assert.IsTrue(comparer.GetHashCode(coll6) == comparer.GetHashCode(coll8));
                    Assert.IsTrue(comparer.GetHashCode(coll2) == comparer.GetHashCode(coll1));
                    Assert.IsTrue(comparer.GetHashCode(coll3) == comparer.GetHashCode(coll3));
                    Assert.IsFalse(comparer.GetHashCode(coll6) == comparer.GetHashCode(coll7));
                    Assert.IsFalse(comparer.GetHashCode(coll3) == comparer.GetHashCode(coll4));
                }
         * 
                [Test]
                public void LexicographicalEqualityComparer3()
                {
                    IEnumerable<string> coll1 = EnumerableFromArray(new string[0]);
                    IEnumerable<string> coll2 = EnumerableFromArray(new string[0]);
                    IEnumerable<string> coll3 = EnumerableFromArray(new string[] { "eric", "foo", "a" });
                    IEnumerable<string> coll4 = EnumerableFromArray(new string[] { "Eric", "Foo", "a" });
                    IEnumerable<string> coll5 = EnumerableFromArray(new string[] { "Eric", "B", "c" });
                    IEnumerable<string> coll6 = EnumerableFromArray(new string[] { "Eric", "FOO", "a", "b" });
                    IEnumerable<string> coll7 = EnumerableFromArray(new string[] { "Snap", "eric" });

                    IEqualityComparer<IEnumerable<string>> comparer = Algorithms.LexicographicalEqualityComparer(StringComparer.InvariantCultureIgnoreCase);

                    Assert.IsTrue(comparer.Equals(coll3, coll4) );
                    Assert.IsTrue(comparer.Equals(coll1, coll2) );
                    Assert.IsFalse(comparer.Equals(coll3, coll5) );
                    Assert.IsFalse(comparer.Equals(coll4, coll6) );

                    Assert.IsTrue(comparer.GetHashCode(coll3) == comparer.GetHashCode(coll4));
                    Assert.IsTrue(comparer.GetHashCode(coll1) == comparer.GetHashCode(coll2));
                    Assert.IsFalse(comparer.GetHashCode(coll3) == comparer.GetHashCode(coll5));
                    Assert.IsFalse(comparer.GetHashCode(coll4) == comparer.GetHashCode(coll6));
                }
        */
        [Test]
        public void Maximum()
        {
            // Empty collection.
            string maxS;
            IEnumerable<string> coll1 = EnumerableFromArray(new string[0]);

            try {
                maxS = Algorithms.Maximum(coll1);
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is InvalidOperationException);
            }

            try {
                maxS = Algorithms.Maximum(coll1, StringComparer.CurrentCulture);
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is InvalidOperationException);
            }

            try {
                maxS = Algorithms.Maximum(coll1, delegate(string s1, string s2) { return string.CompareOrdinal(s1, s2);});
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is InvalidOperationException);
            }

            // float max
            double maxD;
            IEnumerable<double> coll2 = EnumerableFromArray(new double[] { 7.6, -1.2, 19.2, 0, 178.3, -5.4, -17.8});
            maxD = Algorithms.Maximum(coll2);
            Assert.AreEqual(maxD, 178.3);

            // int max
            int maxI;
            IEnumerable<int> coll3 = EnumerableFromArray(new int[] {7, 4, 1, -8, 19, 8, 43, 38, 1, 38, 4});
            maxI = Algorithms.Maximum(coll3, ComparersTests.CompareOddEven);
            Assert.AreEqual(maxI, 38);
            maxI = Algorithms.Maximum(coll3, new GOddEvenComparer());
            Assert.AreEqual(maxI, 38);

            // string max
            IEnumerable<string> coll4 = EnumerableFromArray(new string[] { "foo", "Hello", "a" });
            maxS = Algorithms.Maximum(coll4);
            Assert.AreEqual("Hello", maxS);
            maxS = Algorithms.Maximum(coll4, StringComparer.Ordinal);
            Assert.AreEqual("foo", maxS);

            // one elements
            IEnumerable<string> coll5 = EnumerableFromArray(new string[] {"elvis"});
            maxS = Algorithms.Maximum(coll5);
            Assert.AreEqual("elvis", maxS);
        }


        [Test]
        public void IndexOfMaximum()
        {
            // Empty collection.
            int maxIndex;
            IList<string> coll1 = new List<string>(new string[0]);

            // empty collection
            maxIndex = Algorithms.IndexOfMaximum(coll1);
            Assert.AreEqual(-1, maxIndex);
            maxIndex = Algorithms.IndexOfMaximum(coll1, StringComparer.CurrentCulture);
            Assert.AreEqual(-1, maxIndex);
            maxIndex = Algorithms.IndexOfMaximum(coll1, delegate(string s1, string s2) { return string.CompareOrdinal(s1, s2); });
            Assert.AreEqual(-1, maxIndex);

            // float max
            IList<double> coll2 = new Deque<double>(new double[] { 7.6, -1.2, 19.2, 0, 178.3, -5.4, -17.8 });
            maxIndex = Algorithms.IndexOfMaximum(coll2);
            Assert.AreEqual(maxIndex, 4);

            // int max
            IList<int> coll3 = new BigList<int>(new int[] { 7, 4, 1, -8, 19, 8, 43, 38, 1, 38, 4 });
            maxIndex = Algorithms.IndexOfMaximum(coll3, ComparersTests.CompareOddEven);
            Assert.AreEqual(maxIndex, 7);
            maxIndex = Algorithms.IndexOfMaximum(coll3, new GOddEvenComparer());
            Assert.AreEqual(maxIndex, 7);

            // string max
            IList<string> coll4 = new string[] { "foo", "Hello", "a" };
            maxIndex = Algorithms.IndexOfMaximum(coll4);
            Assert.AreEqual(maxIndex, 1);
            maxIndex = Algorithms.IndexOfMaximum(coll4, StringComparer.Ordinal);
            Assert.AreEqual(maxIndex, 0);

            // one elements
            IList<string> coll5 = new BigList<string>(new string[] { "elvis" });
            maxIndex = Algorithms.IndexOfMaximum(coll5);
            Assert.AreEqual(maxIndex, 0);
        }

        [Test]
        public void Minimum()
        {
            // Empty collection.
            string minS;
            IEnumerable<string> coll1 = EnumerableFromArray(new string[0]);

            try {
                minS = Algorithms.Minimum(coll1);
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is InvalidOperationException);
            }

            try {
                minS = Algorithms.Minimum(coll1, StringComparer.CurrentCulture);
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is InvalidOperationException);
            }

            try {
                minS = Algorithms.Minimum(coll1, delegate(string s1, string s2) { return string.CompareOrdinal(s1, s2); });
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is InvalidOperationException);
            }

            // float min
            double minD;
            IEnumerable<double> coll2 = EnumerableFromArray(new double[] { 7.6, -1.2, 19.2, 0, 178.3, -5.4, -17.8 });
            minD = Algorithms.Minimum(coll2);
            Assert.AreEqual(minD, -17.8);

            // int min
            int minI;
            IEnumerable<int> coll3 = EnumerableFromArray(new int[] { 7, 4, 1, -8, 19, 8, 43, 38, 1, 38, 4 });
            minI = Algorithms.Minimum(coll3, ComparersTests.CompareOddEven);
            Assert.AreEqual(minI, 1);
            minI = Algorithms.Minimum(coll3, new GOddEvenComparer());
            Assert.AreEqual(minI, 1);

            // string min
            IEnumerable<string> coll4 = EnumerableFromArray(new string[] { "foo", "Hello", "a", null });
            minS = Algorithms.Minimum(coll4);
            Assert.AreEqual(null, minS);
            minS = Algorithms.Minimum(coll4, StringComparer.Ordinal);
            Assert.AreEqual(null, minS);

            // string min
            IEnumerable<string> coll5 = EnumerableFromArray(new string[] { "foo", "Hello", "a", "zip" });
            minS = Algorithms.Minimum(coll5);
            Assert.AreEqual("a", minS);
            minS = Algorithms.Minimum(coll5, StringComparer.Ordinal);
            Assert.AreEqual("Hello", minS);

            // one elements
            IEnumerable<string> coll6 = EnumerableFromArray(new string[] { null });
            minS = Algorithms.Minimum(coll6);
            Assert.AreEqual(null, minS);
        }

        [Test]
        public void IndexOfMinimum()
        {
            // Empty collection.
            int minIndex;
            IList<string> coll1 = new List<string>(new string[0]);

            // empty collection
            minIndex = Algorithms.IndexOfMinimum(coll1);
            Assert.AreEqual(-1, minIndex);
            minIndex = Algorithms.IndexOfMinimum(coll1, StringComparer.CurrentCulture);
            Assert.AreEqual(-1, minIndex);
            minIndex = Algorithms.IndexOfMinimum(coll1, delegate(string s1, string s2) { return string.CompareOrdinal(s1, s2); });
            Assert.AreEqual(-1, minIndex);

            // float max
            IList<double> coll2 = new Deque<double>(new double[] { 7.6, -1.2, 19.2, 0, 178.3, -5.4, -17.8 });
            minIndex = Algorithms.IndexOfMinimum(coll2);
            Assert.AreEqual(minIndex, 6);

            // int max
            IList<int> coll3 = new BigList<int>(new int[] { 7, 4, 1, -8, 19, 8, 43, 38, 1, 38, 4 });
            minIndex = Algorithms.IndexOfMinimum(coll3, ComparersTests.CompareOddEven);
            Assert.AreEqual(minIndex, 2);
            minIndex = Algorithms.IndexOfMinimum(coll3, new GOddEvenComparer());
            Assert.AreEqual(minIndex, 2);

            // string max
            IList<string> coll4 = new string[] { "foo", "Hello", "a" };
            minIndex = Algorithms.IndexOfMinimum(coll4);
            Assert.AreEqual(minIndex, 2);
            minIndex = Algorithms.IndexOfMinimum(coll4, StringComparer.Ordinal);
            Assert.AreEqual(minIndex, 1);

            // one elements
            IList<string> coll5 = new BigList<string>(new string[] { "elvis" });
            minIndex = Algorithms.IndexOfMinimum(coll5);
            Assert.AreEqual(minIndex, 0);
        }