multidictionarytests.cs

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

                new KeyValuePair<string,string>("Hello", "AAA"),
                new KeyValuePair<string,string>("Hi", "aaa"),
                new KeyValuePair<string,string>("qubert", "hoover"),
                new KeyValuePair<string,string>("qubert", "dinosaur")});

            MultiDictionary<string, int> dict4 = new MultiDictionary<string, int>(true);
            MultiDictionary<string, int> dict5;
            dict5 = dict4.Clone();
            Assert.IsFalse(dict4 == dict5);
            Assert.IsTrue(dict4.Count == 0 && dict5.Count == 0);
            dict4.Add("hello", 1);
            Assert.IsTrue(dict4.Count == 1 && dict5.Count == 0);
            dict5.Add("hi", 7);
            dict4.Clear();
            Assert.IsTrue(dict4.Count == 0 && dict5.Count == 1);
        }

        void CompareClones<K, V>(MultiDictionary<K, V> d1, MultiDictionary<K, V> d2)
        {
            IEnumerable<KeyValuePair<K, V>> e1 = d1.KeyValuePairs;
            IEnumerable<KeyValuePair<K, V>> e2 = d2.KeyValuePairs;
            KeyValuePair<K, V>[] pairs1 = Algorithms.ToArray<KeyValuePair<K, V>>(e1), pairs2 = Algorithms.ToArray<KeyValuePair<K, V>>(e2);
            bool[] found = new bool[pairs2.Length];

            // Check that the arrays are equal, but not reference equals (e.g., have been cloned).
            Assert.IsTrue(pairs1.Length == pairs2.Length);
            foreach (KeyValuePair<K, V> p1 in pairs1) {
                bool f = false;
                for (int i = 0; i < pairs2.Length; ++i) {
                    if (!found[i] && object.Equals(p1.Key, pairs2[i].Key) && object.Equals(p1.Value, pairs2[i].Value)) {
                        found[i] = true;
                        f = true;
                        Assert.IsTrue(p1.Key == null || !object.ReferenceEquals(p1.Key, pairs2[i].Key));
                        Assert.IsTrue(p1.Value == null || !object.ReferenceEquals(p1.Value, pairs2[i].Value));
                        break;
                    }
                }
                Assert.IsTrue(f);
            }
        }

        private class MyIntComparer : IEqualityComparer<MyInt>
        {
            public bool Equals(MyInt x, MyInt y)
            {
                if (x == null)
                    return y == null;
                else if (y == null)
                    return x == null;
                else
                    return x.value == y.value;
            }

            public int GetHashCode(MyInt obj)
            {
                if (obj == null)
                    return 0x42834E;
                else
                    return obj.value.GetHashCode();
            }
        }

        [Test]
        public void CloneContents()
        {
            MyIntComparer comparer = new MyIntComparer();
            MultiDictionary<int, MyInt> dict1 = new MultiDictionary<int, MyInt>(true, EqualityComparer<int>.Default, comparer);

            dict1.Add(4, new MyInt(143));
            dict1.Add(7, new MyInt(2));
            dict1.Add(11, new MyInt(9));
            dict1.Add(7, new MyInt(119));
            dict1.Add(18, null);
            dict1.Add(4, new MyInt(16));
            dict1.Add(7, null);
            dict1.Add(7, new MyInt(119));
            MultiDictionary<int, MyInt> dict2 = dict1.CloneContents();
            CompareClones(dict1, dict2);

            MultiDictionary<MyInt, int> dict3 = new MultiDictionary<MyInt, int>(false, comparer);

            dict3.Add(new MyInt(4), 143);
            dict3.Add(new MyInt(7), 2);
            dict3.Add(new MyInt(11), 9);
            dict3.Add(new MyInt(7), 119);
            dict3.Add(new MyInt(18), 0);
            dict3.Add(new MyInt(4), 16);
            dict3.Add(null, 11);
            dict3.Add(new MyInt(7), 119);

            MultiDictionary<MyInt, int> dict4 = dict3.CloneContents();
            CompareClones(dict3, dict4);

            MultiDictionary<UtilTests.CloneableStruct, UtilTests.CloneableStruct> dict5 = new MultiDictionary<UtilTests.CloneableStruct, UtilTests.CloneableStruct>(true);
            dict5.Add(new UtilTests.CloneableStruct(7), new UtilTests.CloneableStruct(-14));
            dict5.Add(new UtilTests.CloneableStruct(16), new UtilTests.CloneableStruct(13));
            dict5.Add(new UtilTests.CloneableStruct(7), new UtilTests.CloneableStruct(-14));
            dict5.Add(new UtilTests.CloneableStruct(7), new UtilTests.CloneableStruct(31415));
            dict5.Add(new UtilTests.CloneableStruct(1111), new UtilTests.CloneableStruct(0));
            MultiDictionary<UtilTests.CloneableStruct, UtilTests.CloneableStruct> dict6 = dict5.CloneContents();

            Assert.IsTrue(dict5.Count == dict6.Count);

            IEnumerable<KeyValuePair<UtilTests.CloneableStruct, UtilTests.CloneableStruct>> e1 = dict5.KeyValuePairs;
            IEnumerable<KeyValuePair<UtilTests.CloneableStruct, UtilTests.CloneableStruct>> e2 = dict6.KeyValuePairs;
            KeyValuePair<UtilTests.CloneableStruct, UtilTests.CloneableStruct>[] pairs1 = Algorithms.ToArray<KeyValuePair<UtilTests.CloneableStruct, UtilTests.CloneableStruct>>(e1), pairs2 = Algorithms.ToArray<KeyValuePair<UtilTests.CloneableStruct, UtilTests.CloneableStruct>>(e2);
            bool[] found = new bool[pairs2.Length];

            // Check that the arrays are equal, but not reference equals (e.g., have been cloned).
            Assert.IsTrue(pairs1.Length == pairs2.Length);
            foreach (KeyValuePair<UtilTests.CloneableStruct, UtilTests.CloneableStruct> p1 in pairs1) {
                bool f = false;
                for (int i = 0; i < pairs2.Length; ++i) {
                    if (!found[i] && object.Equals(p1.Key, pairs2[i].Key) && object.Equals(p1.Value, pairs2[i].Value)) {
                        found[i] = true;
                        f = true;
                        Assert.IsFalse(p1.Key.Identical(pairs2[i].Key));
                        Assert.IsFalse(p1.Value.Identical(pairs2[i].Value));
                        break;
                    }
                }
                Assert.IsTrue(f);
            }

        }

        class NotCloneable { }

        [Test, ExpectedException(typeof(InvalidOperationException))]
        public void CantCloneContents()
        {
            MultiDictionary<int, NotCloneable> dict1 = new MultiDictionary<int, NotCloneable>(true);

            dict1[4] = new NotCloneable[] { new NotCloneable() };
            dict1[5] = new NotCloneable[] { new NotCloneable(), new NotCloneable() };

            MultiDictionary<int, NotCloneable> dict2 = dict1.CloneContents();
        }


        [Test]
        public void FailFastEnumerator()
        {
            MultiDictionary<string, int> dict1 = new MultiDictionary<string, int>(true);
            bool throwNow;

            dict1.Add("foo", 12);
            dict1.Add("foo", 15);
            dict1.Add("foo", 3);
            dict1.Add("foo", 12);
            dict1.Add("bar", 1);
            dict1.Add("bar", 17);

            throwNow = false;
            try {
                foreach (KeyValuePair<string, int> pair in dict1.KeyValuePairs) {
                    throwNow = false;
                    if (pair.Key == "foo") {
                        dict1.Replace("bar", 19);
                        throwNow = true;
                    }
                }
            }
            catch (Exception e) {
                Assert.IsTrue(e is InvalidOperationException);
                Assert.IsTrue(throwNow);
            }

            throwNow = false;
            try {
                foreach (string key in dict1.Keys) {
                    throwNow = false;
                    if (key == "foo") {
                        dict1.Add("grump", 117);
                        throwNow = true;
                    }
                }
            }
            catch (Exception e) {
                Assert.IsTrue(e is InvalidOperationException);
                Assert.IsTrue(throwNow);
            }

            throwNow = false;
            try {
                foreach (int value in dict1["foo"]) {
                    throwNow = false;
                    if (value == 12) {
                        dict1.Remove("grump", 117);
                        throwNow = true;
                    }
                }
            }
            catch (Exception e) {
                Assert.IsTrue(e is InvalidOperationException);
                Assert.IsTrue(throwNow);
            }

            throwNow = false;
            try {
                foreach (string key in dict1.Keys) {
                    throwNow = false;
                    if (key == "foo") {
                        dict1.Clear();
                        throwNow = true;
                    }
                }
            }
            catch (Exception e) {
                Assert.IsTrue(e is InvalidOperationException);
                Assert.IsTrue(throwNow);
            }

        }

        [Test]
        public void KeyComparerProperty()
        {
            IEqualityComparer<int> comparer1 = new GOddEvenEqualityComparer();
            MultiDictionary<int, string> dict1 = new MultiDictionary<int, string>(false, comparer1);
            Assert.AreSame(comparer1, dict1.KeyComparer);
            MultiDictionary<decimal, string> dict2 = new MultiDictionary<decimal, string>(true);
            Assert.AreSame(EqualityComparer<decimal>.Default, dict2.KeyComparer);
            MultiDictionary<string, string> dict3 = new MultiDictionary<string, string>(true, StringComparer.OrdinalIgnoreCase, StringComparer.CurrentCulture);
            Assert.AreSame(StringComparer.OrdinalIgnoreCase, dict3.KeyComparer);

            Assert.AreSame(dict1.KeyComparer, dict1.Clone().KeyComparer);
            Assert.AreSame(dict2.KeyComparer, dict2.Clone().KeyComparer);
            Assert.AreSame(dict3.KeyComparer, dict3.Clone().KeyComparer);
        }

        [Test]
        public void ValueComparerProperty()
        {
            IEqualityComparer<int> comparer1 = new GOddEvenEqualityComparer();
            MultiDictionary<string, int> dict1 = new MultiDictionary<string, int>(true, StringComparer.InvariantCulture, comparer1);
            Assert.AreSame(comparer1, dict1.ValueComparer);
            MultiDictionary<string, decimal> dict2 = new MultiDictionary<string, decimal>(false);
            Assert.AreSame(EqualityComparer<decimal>.Default, dict2.ValueComparer);
            MultiDictionary<string, string> dict3 = new MultiDictionary<string, string>(true, StringComparer.InvariantCulture, StringComparer.OrdinalIgnoreCase);
            Assert.AreSame(StringComparer.OrdinalIgnoreCase, dict3.ValueComparer);

            Assert.AreSame(dict1.ValueComparer, dict1.Clone().ValueComparer);
            Assert.AreSame(dict2.ValueComparer, dict2.Clone().ValueComparer);
            Assert.AreSame(dict3.ValueComparer, dict3.Clone().ValueComparer);
        }

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

            d.Add("hEllo", 13);
            d.Add("foo", 7);
            d.Add("world", -9.5);
            d.Add("hello", 11);
            d.Add("elvis", 0.9);
            d.Add("ELVIS", 1.4);
            d.Add(null, 1.4);
            d.Add("FOO", 7);
            d.Add("hello", 12);

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

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

        [Serializable]
        class UniqueStuff
        {
            public InterfaceTests.Unique[] keys;
            public InterfaceTests.Unique[] values;
            public MultiDictionary<InterfaceTests.Unique, InterfaceTests.Unique> dict;
        }


        [Test]
        public void SerializeUnique()
        {
            UniqueStuff d = new UniqueStuff(), result = new UniqueStuff();

            d.keys = new InterfaceTests.Unique[] {
                new InterfaceTests.Unique("1"), new InterfaceTests.Unique("2"), new InterfaceTests.Unique("3"), new InterfaceTests.Unique("4"), new InterfaceTests.Unique("5")
            };

            d.values = new InterfaceTests.Unique[] {
                new InterfaceTests.Unique("a"), new InterfaceTests.Unique("b"), new InterfaceTests.Unique("c"), new InterfaceTests.Unique("d"), new InterfaceTests.Unique("e"), new InterfaceTests.Unique("f"), new InterfaceTests.Unique("g")
            };


            d.dict = new MultiDictionary<InterfaceTests.Unique, InterfaceTests.Unique>(true);

            d.dict.Add(d.keys[2], d.values[4]);
            d.dict.Add(d.keys[0], d.values[0]);
            d.dict.Add(d.keys[1], d.values[1]);
            d.dict.Add(d.keys[2], d.values[2]);
            d.dict.Add(d.keys[3], d.values[5]);
            d.dict.Add(d.keys[3], d.values[6]);
            d.dict.Add(d.keys[4], d.values[6]);
            d.dict.Add(d.keys[0], d.values[0]);
            d.dict.Add(d.keys[2], d.values[3]);

            result = (UniqueStuff)InterfaceTests.SerializeRoundTrip(d);

            CheckMultiDictionaryContents<InterfaceTests.Unique, InterfaceTests.Unique>(result.dict,
                result.keys,
                new InterfaceTests.Unique[][] { new InterfaceTests.Unique[] { result.values[0], result.values[0] }, new InterfaceTests.Unique[] { result.values[1] }, new InterfaceTests.Unique[] { result.values[2], result.values[3], result.values[4] }, new InterfaceTests.Unique[] { result.values[5], result.values[6] }, new InterfaceTests.Unique[] { result.values[6] } },
                new InterfaceTests.Unique("foo"), new InterfaceTests.Unique("bar"), null, null);

            for (int i = 0; i < result.keys.Length; ++i) {
                if (result.keys[i] != null)
                    Assert.IsFalse(object.Equals(result.keys[i], d.keys[i]));
            }

            for (int i = 0; i < result.values.Length; ++i) {
                if (result.values[i] != null)
                    Assert.IsFalse(object.Equals(result.values[i], d.values[i]));
            }
        }
        
    }
}