ordereddictionarytests.cs

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

                                        new int[] { -9, 9, 199, 1234, 198, 23, 7, 11 },
                                        "");
            CheckView(dict1.Range("f", true, "s", false).Reversed(),
                                        new string[] { "r4", "q", "p", "hello", "foo"},
                                        new int[] { 9, 199, 1234, 198, 23},
                                        "a");
            CheckView(dict1.Range("f", false, "s", true).Reversed(),
                                        new string[] { "r4", "q", "p", "hello", "foo" },
                                        new int[] { 9, 199, 1234, 198, 23 },
                                        "a");

            CheckView(dict1.RangeFrom("hello", true),
                                        new string[] { "hello", "p", "q", "r4", "ww" },
                                        new int[] { 198, 1234, 199, 9, -9 },
                                        "b");
            CheckView(dict1.RangeFrom("hello", false),
                                        new string[] { "p", "q", "r4", "ww" },
                                        new int[] { 1234, 199, 9, -9 },
                                        "b");
            CheckView(dict1.RangeFrom("z", true),
                                        new string[] { },
                                        new int[] {  },
                                        "ww");
            CheckView(dict1.RangeFrom("z", false),
                                        new string[] { },
                                        new int[] { },
                                        "ww");
            CheckView(dict1.RangeTo("hello", false),
                                        new string[] { "", "a", "b", "foo" },
                                        new int[] { 981, 11, 7, 23 },
                                        "hello");
            CheckView(dict1.RangeTo("hello", true),
                                        new string[] { "", "a", "b", "foo", "hello" },
                                        new int[] { 981, 11, 7, 23, 198 },
                                        "q");
            CheckView(dict1.RangeTo("", false),
                                        new string[] { },
                                        new int[] {  },
                                        "");
            CheckView(dict1.RangeTo("", true),
                                        new string[] { ""},
                                        new int[] {981  },
                                        "1");
        }

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

            OrderedDictionary<int, string> dict1 = new OrderedDictionary<int, string>(myComparer);
            dict1[3] = "foo";
            dict1[8] = "bar";
            dict1[9] = "baz";
            dict1[12] = "biff";

            InterfaceTests.TestReadonlyCollectionGeneric<int>(dict1.Keys, new int[] { 3, 9, 8, 12 }, true, "KeysCollection");
            InterfaceTests.TestReadonlyCollectionGeneric<string>(dict1.Values, new string[] { "foo", "baz", "bar", "biff" }, true, "ValuesCollection");
        }

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

            OrderedDictionary<int, string> dict1 = new OrderedDictionary<int, string>(myOrdering);
            dict1[3] = "foo";
            dict1[8] = "bar";
            dict1[9] = "baz";
            dict1[12] = "biff";

            InterfaceTests.TestReadonlyCollectionGeneric<int>(dict1.Keys, new int[] { 3, 9, 8, 12 }, true, "KeysCollection");
            InterfaceTests.TestReadonlyCollectionGeneric<string>(dict1.Values, new string[] { "foo", "baz", "bar", "biff" }, true, "ValuesCollection");
        }

        // Check that cloned dictionaries maintain a custom ordering.
        [Test]
        public void CloneCustomOrdering()
        {
            Comparison<int> myOrdering = ComparersTests.CompareOddEven;

            OrderedDictionary<int, string> dict1 = new OrderedDictionary<int, string>(myOrdering);
            dict1[3] = "foo";
            dict1[8] = "bar";
            dict1[9] = "baz";
            dict1[12] = "biff";

            OrderedDictionary<int, string> dict2 = dict1.Clone();
            OrderedDictionary<int, string> dict3 = dict1.CloneContents();
            dict1[7] = "goofy";

            InterfaceTests.TestReadWriteDictionaryGeneric<int, string>(dict2, new int[] { 3, 9, 8, 12 }, new string[] { "foo", "baz", "bar", "biff" }, 7, true, null, null, null);
            InterfaceTests.TestReadWriteDictionaryGeneric<int, string>(dict3, new int[] { 3, 9, 8, 12 }, new string[] { "foo", "baz", "bar", "biff" }, 7, true, null, null, null);
        }

        // Test that it looks like a non-generic ICollection of DictionaryEntrys.
        [Test]
        public void ICollectionMembers()
        {
            OrderedDictionary<int, string> dict1 = new OrderedDictionary<int, string>();
            dict1[9] = "baz";
            dict1[8] = "bar";
            dict1[12] = "biff";
            dict1[3] = "foo";

            InterfaceTests.TestCollection<DictionaryEntry>((ICollection)dict1,
                new DictionaryEntry[] {
                    new DictionaryEntry(3, "foo"), 
                    new DictionaryEntry(8, "bar"), 
                    new DictionaryEntry(9, "baz"), 
                    new DictionaryEntry(12, "biff") },
                true);
        }

        // Test that it looks like a non-generic ICollection of DictionaryEntrys.
        [Test]
        public void GenericICollectionMembers()
        {
            OrderedDictionary<int, string> dict1 = new OrderedDictionary<int, string>();
            dict1[9] = "baz";
            dict1[8] = "bar";
            dict1[12] = "biff";
            dict1[3] = "foo";

            InterfaceTests.TestReadWriteCollectionGeneric<KeyValuePair<int, string>>((ICollection<KeyValuePair<int, string>>)dict1, 
                new KeyValuePair<int,string>[] {
                    new KeyValuePair<int,string>(3, "foo"), 
                    new KeyValuePair<int,string>(8, "bar"), 
                    new KeyValuePair<int,string>(9, "baz"), 
                    new KeyValuePair<int,string>(12, "biff") },
                true);
        }

        [Test]
        public void AddMany()
        {
            OrderedDictionary<int, string> dict1 = new OrderedDictionary<int, string>();
            Dictionary<int, string> dict2 = new Dictionary<int, string>();

            dict1[9] = "baz";
            dict1[8] = "bar";
            dict1[12] = "biff";
            dict1[3] = "foo";

            dict2[0] = "fribble";
            dict2[8] = "banana";
            dict2[123] = "biff";
            dict2[3] = "hello";

            dict1.AddMany(dict2);

            InterfaceTests.TestReadWriteCollectionGeneric<KeyValuePair<int, string>>((ICollection<KeyValuePair<int, string>>)dict1,
               new KeyValuePair<int, string>[] {
                    new KeyValuePair<int,string>(0, "fribble"), 
                    new KeyValuePair<int,string>(3, "hello"), 
                    new KeyValuePair<int,string>(8, "banana"), 
                    new KeyValuePair<int,string>(9, "baz"), 
                    new KeyValuePair<int,string>(12, "biff"),
                    new KeyValuePair<int,string>(123, "biff")},
               true);
        }

        [Test]
        public void RemoveCollection()
        {
            OrderedDictionary<int, string> dict1 = new OrderedDictionary<int, string>();

            dict1[9] = "baz";
            dict1[8] = "bar";
            dict1[12] = "biff";
            dict1[3] = "foo";
            dict1[127] = "hello";

            int[] array = new int[] { 8, 127, 4, 3 };

            int count = dict1.RemoveMany(array);
            Assert.AreEqual(3, count);

            InterfaceTests.TestReadWriteCollectionGeneric<KeyValuePair<int, string>>((ICollection<KeyValuePair<int, string>>)dict1,
               new KeyValuePair<int, string>[] {
                    new KeyValuePair<int,string>(9, "baz"), 
                    new KeyValuePair<int,string>(12, "biff") },
               true);
        }

        private void CheckNullKeyException(Exception e, string paramName) {
            Assert.IsTrue(e is ArgumentNullException);
            Assert.IsTrue(((ArgumentNullException)e).ParamName == paramName);
        }

        private void CheckNullKeyException(Exception e)
        {
            CheckNullKeyException(e, "key");
        }
        [Test]
        public void IDictionaryInterface()
        {
            string[] s_array = { "Eric", "Clapton", "Rules", "The", "World" };
            int[] i_array = { 1, 5, 6, 5, 19 };
            string[] s_array_sorted = { "Clapton", "Eric", "Rules", "The", "World" };
            int[] i_array_sorted = { 5, 1, 6, 5, 19 };

            OrderedDictionary<string, int> dict1 = new OrderedDictionary<string, int>();
            for (int i = 0; i < s_array.Length; ++i) {
                dict1.Add(s_array[i], i_array[i]);
            }

            InterfaceTests.TestReadWriteDictionary<string, int>(dict1, s_array_sorted, i_array_sorted, "foo", true, "ReadOnlyTestDictionary");
            InterfaceTests.TestReadWriteDictionaryGeneric<string, int>(dict1, s_array_sorted, i_array_sorted, "foo", true, "ReadOnlyTestDictionary", null, null);
        }

        [Test, ExpectedException(typeof(InvalidOperationException))]
        public void FailFastEnumerator1()
        {
            OrderedDictionary<double, int> dict1 = new OrderedDictionary<double, int>();

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

            // enumeration of the Keys collection should throw once the dictionary is modified.
            foreach (double k in dict1.Keys) {
                if (k > 3.0)
                    dict1[4.5] = 9;
            }
        }

        [Test, ExpectedException(typeof(InvalidOperationException))]
        public void FailFastEnumerator2()
        {
            OrderedDictionary<double, int> dict1 = new OrderedDictionary<double, int>();

            double d = 1.218034;
            for (int i = 0; i < 100; ++i) {
                dict1[d] = i;
                d = d * 1.3451 - .31;
            }

            // enumeration of a view should throw once the dictionary is modified.
            foreach (KeyValuePair<double,int> p in dict1.Range(1.7, true, 11.4, false)) {
                if (p.Key > 7.0)
                    dict1.Clear();
            }
        }

        [Test]
        public void ComparerProperty()
        {
            IComparer<int> comparer1 = new GOddEvenComparer();
            OrderedDictionary<int, string> dict1 = new OrderedDictionary<int, string>(comparer1);
            Assert.AreSame(comparer1, dict1.Comparer);
            OrderedDictionary<decimal, string> dict2 = new OrderedDictionary<decimal, string>();
            Assert.AreSame(Comparer<decimal>.Default, dict2.Comparer);
            OrderedDictionary<string, string> dict3 = new OrderedDictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            Assert.AreSame(StringComparer.OrdinalIgnoreCase, dict3.Comparer);

            Comparison<int> comparison1 = ComparersTests.CompareOddEven;
            OrderedDictionary<int, string> dict4 = new OrderedDictionary<int, string>(comparison1);
            OrderedDictionary<int, string> dict5 = new OrderedDictionary<int, string>(comparison1);
            Assert.AreEqual(dict4.Comparer, dict5.Comparer);
            Assert.IsFalse(dict4.Comparer == dict5.Comparer);
            Assert.IsFalse(object.Equals(dict4.Comparer, dict1.Comparer));
            Assert.IsFalse(object.Equals(dict4.Comparer, Comparer<int>.Default));
            Assert.IsTrue(dict4.Comparer.Compare(7, 6) < 0);

            Assert.AreSame(dict1.Comparer, dict1.Clone().Comparer);
            Assert.AreSame(dict2.Comparer, dict2.Clone().Comparer);
            Assert.AreSame(dict3.Comparer, dict3.Clone().Comparer);
            Assert.AreSame(dict4.Comparer, dict4.Clone().Comparer);
            Assert.AreSame(dict5.Comparer, dict5.Clone().Comparer);
        }


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

            d.Add("hEllo", 13);
            d.Add("foo", 7);
            d.Add("world", -9.5);
            d.Add("elvis", 0.9);
            d.Add(null, 1.4);

            OrderedDictionary<string, double> result = (OrderedDictionary<string, double>)InterfaceTests.SerializeRoundTrip(d);

            InterfaceTests.TestDictionaryGeneric<String, double>(result,
                new string[] { null, "eLVis", "FOO", "Hello", "WORLD" },
                new double[] {  1.4, 0.9, 7, 13, -9.5 },
                "zippy", true, StringComparer.InvariantCultureIgnoreCase.Equals, null);
        }

        [Test]
        public void ConstructionWithInitialization()
        {
            Dictionary<string, int> init = new Dictionary<string, int>();

            init["foo"] = 16;
            init["FOO"] = 19;
            init["fiddle"] = 107;
            init["goofy"] = 11;
            init["trackstar"] = 19;
            init["GOOfy"] = 110;
            init["bar"] = 99;

            OrderedDictionary<string, int> dict1 = new OrderedDictionary<string, int>(init);

            InterfaceTests.TestDictionaryGeneric<string, int>(dict1,
                new string[] { "bar", "fiddle", "foo", "FOO", "goofy", "GOOfy", "trackstar" },
                new int[] { 99, 107, 16, 19, 11, 110, 19 },
                "zippy", true, null, null);

            OrderedDictionary<string, int> dict2 = new OrderedDictionary<string, int>(dict1, Algorithms.GetReverseComparer(StringComparer.InvariantCultureIgnoreCase));

            InterfaceTests.TestDictionaryGeneric<string, int>(dict2,
                new string[] { "trackstar", "GOOfy", "FOO", "fiddle", "bar" },
                new int[] { 19, 110, 19, 107, 99 },
                "zippy", true, null, null);

            Comparison<string> myComparison = delegate(string x, string y) {
                return x[0].CompareTo(y[0]);
            };

            OrderedDictionary<string, int> dict3 = new OrderedDictionary<string, int>(dict1, Algorithms.GetReverseComparison(myComparison));

            InterfaceTests.TestDictionaryGeneric<string, int>(dict3,
                new string[] { "trackstar", "goofy", "foo", "bar", "GOOfy", "FOO"},
                new int[] { 19, 11, 16, 99, 110, 19},
                "zippy", true, null, null);

        }

    }
}