tripletests.cs

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

            Assert.IsTrue(triple1.Equals(triple3));
            Assert.IsFalse(triple1 == triple2);
            Assert.IsTrue(triple1 == triple3);

            Assert.IsFalse(triple1.GetHashCode() == triple2.GetHashCode());
            Assert.IsTrue(triple1.GetHashCode() == triple3.GetHashCode());
        }

        [Test]
        public void NongenericComparable()
        {
            Triple<int, OddEvenComparable, string> triple1, triple2;

            triple1 = new Triple<int, OddEvenComparable, string>(4, new OddEvenComparable(7), "B");
            triple2 = new Triple<int, OddEvenComparable, string>(7, new OddEvenComparable(3), "A");
            Assert.IsTrue(triple1.CompareTo(triple2) < 0);
            Assert.IsFalse(triple1.Equals(triple2));
            Assert.IsFalse(triple1.GetHashCode() == triple2.GetHashCode());

            triple1 = new Triple<int, OddEvenComparable, string>(4, new OddEvenComparable(7), "B");
            triple2 = new Triple<int, OddEvenComparable, string>(4, new OddEvenComparable(2), "A");
            Assert.IsTrue(triple1.CompareTo(triple2) < 0);
            Assert.IsFalse(triple1.Equals(triple2));
            Assert.IsFalse(triple1.GetHashCode() == triple2.GetHashCode());

            triple1 = new Triple<int, OddEvenComparable, string>(4, new OddEvenComparable(7), "A");
            triple2 = new Triple<int, OddEvenComparable, string>(4, new OddEvenComparable(7), "A");
            Assert.IsTrue(triple1.CompareTo(triple2) == 0);
            Assert.IsTrue(triple1.Equals(triple2));
            Assert.IsTrue(triple1.GetHashCode() == triple2.GetHashCode());

            triple1 = new Triple<int, OddEvenComparable, string>(7, new OddEvenComparable(7), "B");
            triple2 = new Triple<int, OddEvenComparable, string>(4, new OddEvenComparable(2), "C");
            Assert.IsTrue(triple1.CompareTo(triple2) > 0);
            Assert.IsFalse(triple1.Equals(triple2));
            Assert.IsFalse(triple1.GetHashCode() == triple2.GetHashCode());

            triple1 = new Triple<int, OddEvenComparable, string>(0, new OddEvenComparable(8), "A");
            triple2 = new Triple<int, OddEvenComparable, string>(0, new OddEvenComparable(2), "A");
            Assert.IsTrue(triple1.CompareTo(triple2) > 0);
            Assert.IsFalse(triple1.Equals(triple2));
            Assert.IsFalse(triple1.GetHashCode() == triple2.GetHashCode());

            Triple<OddEvenComparable, int, string> triple3, triple4;

            triple3 = new Triple<OddEvenComparable, int, string>(new OddEvenComparable(7), 4,"A");
            triple4 = new Triple<OddEvenComparable, int, string>(new OddEvenComparable(3), 7, "B");
            Assert.IsTrue(triple3.CompareTo(triple4) > 0);
            Assert.IsFalse(triple3.Equals(triple4));
            Assert.IsFalse(triple3.GetHashCode() == triple4.GetHashCode());

            triple3 = new Triple<OddEvenComparable, int, string>(new OddEvenComparable(7), 4, "B");
            triple4 = new Triple<OddEvenComparable, int, string>(new OddEvenComparable(2), 4, "A");
            Assert.IsTrue(triple3.CompareTo(triple4) < 0);
            Assert.IsFalse(triple3.Equals(triple4));
            Assert.IsFalse(triple3.GetHashCode() == triple4.GetHashCode());

            triple3 = new Triple<OddEvenComparable, int, string>(new OddEvenComparable(7), 4, "C");
            triple4 = new Triple<OddEvenComparable, int, string>(new OddEvenComparable(7), 4, "C");
            Assert.IsTrue(triple3.CompareTo(triple4) == 0);
            Assert.IsTrue(triple3.Equals(triple4));
            Assert.IsTrue(triple3.GetHashCode() == triple4.GetHashCode());

            triple3 = new Triple<OddEvenComparable, int, string>(new OddEvenComparable(2), 7, "A");
            triple4 = new Triple<OddEvenComparable, int, string>(new OddEvenComparable(7), 4, "B");
            Assert.IsTrue(triple3.CompareTo(triple4) > 0);
            Assert.IsFalse(triple3.Equals(triple4));
            Assert.IsFalse(triple3.GetHashCode() == triple4.GetHashCode());

            triple3 = new Triple<OddEvenComparable, int, string>(new OddEvenComparable(8), 0, "A");
            triple4 = new Triple<OddEvenComparable, int, string>(new OddEvenComparable(2), 0,"A");
            Assert.IsTrue(triple3.CompareTo(triple4) > 0);
            Assert.IsFalse(triple3.Equals(triple4));
            Assert.IsFalse(triple3.GetHashCode() == triple4.GetHashCode());

            triple3 = new Triple<OddEvenComparable, int, string>(new OddEvenComparable(2), 4, "A");
            triple4 = new Triple<OddEvenComparable, int, string>(new OddEvenComparable(2), 3, "B");
            Assert.IsTrue(triple3.CompareTo(triple4) > 0);
            Assert.IsFalse(triple3.Equals(triple4));
            Assert.IsFalse(triple3.GetHashCode() == triple4.GetHashCode());

            Triple<int, string, OddEvenComparable> triple5, triple6;

            triple5 = new Triple<int, string, OddEvenComparable>(4, "B", new OddEvenComparable(7));
            triple6 = new Triple<int, string, OddEvenComparable>(7, "A", new OddEvenComparable(3));
            Assert.IsTrue(triple5.CompareTo(triple6) < 0);
            Assert.IsFalse(triple5.Equals(triple6));
            Assert.IsFalse(triple5.GetHashCode() == triple6.GetHashCode());

            triple5 = new Triple<int, string, OddEvenComparable>(4, "A", new OddEvenComparable(7));
            triple6 = new Triple<int, string, OddEvenComparable>(4, "A", new OddEvenComparable(2));
            Assert.IsTrue(triple5.CompareTo(triple6) < 0);
            Assert.IsFalse(triple5.Equals(triple6));
            Assert.IsFalse(triple5.GetHashCode() == triple6.GetHashCode());

            triple5 = new Triple<int, string, OddEvenComparable>(4, "A", new OddEvenComparable(7));
            triple6 = new Triple<int, string, OddEvenComparable>(4, "A", new OddEvenComparable(7));
            Assert.IsTrue(triple5.CompareTo(triple6) == 0);
            Assert.IsTrue(triple5.Equals(triple6));
            Assert.IsTrue(triple5.GetHashCode() == triple6.GetHashCode());

            triple5 = new Triple<int, string, OddEvenComparable>(7, "B", new OddEvenComparable(7));
            triple6 = new Triple<int, string, OddEvenComparable>(4, "C", new OddEvenComparable(2));
            Assert.IsTrue(triple5.CompareTo(triple6) > 0);
            Assert.IsFalse(triple5.Equals(triple6));
            Assert.IsFalse(triple5.GetHashCode() == triple6.GetHashCode());

            triple5 = new Triple<int, string, OddEvenComparable>(0, "A", new OddEvenComparable(8));
            triple6 = new Triple<int, string, OddEvenComparable>(0, "A", new OddEvenComparable(2));
            Assert.IsTrue(triple5.CompareTo(triple6) > 0);
            Assert.IsFalse(triple5.Equals(triple6));
            Assert.IsFalse(triple5.GetHashCode() == triple6.GetHashCode());
        }

        [Test]
        public void GenericComparable()
        {
            Triple<int, GOddEvenComparable, string> triple1, triple2;

            triple1 = new Triple<int, GOddEvenComparable, string>(4, new GOddEvenComparable(7), "B");
            triple2 = new Triple<int, GOddEvenComparable, string>(7, new GOddEvenComparable(3), "A");
            Assert.IsTrue(triple1.CompareTo(triple2) < 0);
            Assert.IsFalse(triple1.Equals(triple2));
            Assert.IsFalse(triple1.GetHashCode() == triple2.GetHashCode());

            triple1 = new Triple<int, GOddEvenComparable, string>(4, new GOddEvenComparable(7), "B");
            triple2 = new Triple<int, GOddEvenComparable, string>(4, new GOddEvenComparable(2), "A");
            Assert.IsTrue(triple1.CompareTo(triple2) < 0);
            Assert.IsFalse(triple1.Equals(triple2));
            Assert.IsFalse(triple1.GetHashCode() == triple2.GetHashCode());

            triple1 = new Triple<int, GOddEvenComparable, string>(4, new GOddEvenComparable(7), "A");
            triple2 = new Triple<int, GOddEvenComparable, string>(4, new GOddEvenComparable(7), "A");
            Assert.IsTrue(triple1.CompareTo(triple2) == 0);
            Assert.IsTrue(triple1.Equals(triple2));
            Assert.IsTrue(triple1.GetHashCode() == triple2.GetHashCode());

            triple1 = new Triple<int, GOddEvenComparable, string>(7, new GOddEvenComparable(7), "B");
            triple2 = new Triple<int, GOddEvenComparable, string>(4, new GOddEvenComparable(2), "C");
            Assert.IsTrue(triple1.CompareTo(triple2) > 0);
            Assert.IsFalse(triple1.Equals(triple2));
            Assert.IsFalse(triple1.GetHashCode() == triple2.GetHashCode());

            triple1 = new Triple<int, GOddEvenComparable, string>(0, new GOddEvenComparable(8), "A");
            triple2 = new Triple<int, GOddEvenComparable, string>(0, new GOddEvenComparable(2), "A");
            Assert.IsTrue(triple1.CompareTo(triple2) > 0);
            Assert.IsFalse(triple1.Equals(triple2));
            Assert.IsFalse(triple1.GetHashCode() == triple2.GetHashCode());

            Triple<GOddEvenComparable, int, string> triple3, triple4;

            triple3 = new Triple<GOddEvenComparable, int, string>(new GOddEvenComparable(7), 4, "A");
            triple4 = new Triple<GOddEvenComparable, int, string>(new GOddEvenComparable(3), 7, "B");
            Assert.IsTrue(triple3.CompareTo(triple4) > 0);
            Assert.IsFalse(triple3.Equals(triple4));
            Assert.IsFalse(triple3.GetHashCode() == triple4.GetHashCode());

            triple3 = new Triple<GOddEvenComparable, int, string>(new GOddEvenComparable(7), 4, "B");
            triple4 = new Triple<GOddEvenComparable, int, string>(new GOddEvenComparable(2), 4, "A");
            Assert.IsTrue(triple3.CompareTo(triple4) < 0);
            Assert.IsFalse(triple3.Equals(triple4));
            Assert.IsFalse(triple3.GetHashCode() == triple4.GetHashCode());

            triple3 = new Triple<GOddEvenComparable, int, string>(new GOddEvenComparable(7), 4, "C");
            triple4 = new Triple<GOddEvenComparable, int, string>(new GOddEvenComparable(7), 4, "C");
            Assert.IsTrue(triple3.CompareTo(triple4) == 0);
            Assert.IsTrue(triple3.Equals(triple4));
            Assert.IsTrue(triple3.GetHashCode() == triple4.GetHashCode());

            triple3 = new Triple<GOddEvenComparable, int, string>(new GOddEvenComparable(2), 7, "A");
            triple4 = new Triple<GOddEvenComparable, int, string>(new GOddEvenComparable(7), 4, "B");
            Assert.IsTrue(triple3.CompareTo(triple4) > 0);
            Assert.IsFalse(triple3.Equals(triple4));
            Assert.IsFalse(triple3.GetHashCode() == triple4.GetHashCode());

            triple3 = new Triple<GOddEvenComparable, int, string>(new GOddEvenComparable(8), 0, "A");
            triple4 = new Triple<GOddEvenComparable, int, string>(new GOddEvenComparable(2), 0, "A");
            Assert.IsTrue(triple3.CompareTo(triple4) > 0);
            Assert.IsFalse(triple3.Equals(triple4));
            Assert.IsFalse(triple3.GetHashCode() == triple4.GetHashCode());

            triple3 = new Triple<GOddEvenComparable, int, string>(new GOddEvenComparable(2), 4, "A");
            triple4 = new Triple<GOddEvenComparable, int, string>(new GOddEvenComparable(2), 3, "B");
            Assert.IsTrue(triple3.CompareTo(triple4) > 0);
            Assert.IsFalse(triple3.Equals(triple4));
            Assert.IsFalse(triple3.GetHashCode() == triple4.GetHashCode());

            Triple<int, string, GOddEvenComparable> triple5, triple6;

            triple5 = new Triple<int, string, GOddEvenComparable>(4, "B", new GOddEvenComparable(7));
            triple6 = new Triple<int, string, GOddEvenComparable>(7, "A", new GOddEvenComparable(3));
            Assert.IsTrue(triple5.CompareTo(triple6) < 0);
            Assert.IsFalse(triple5.Equals(triple6));
            Assert.IsFalse(triple5.GetHashCode() == triple6.GetHashCode());

            triple5 = new Triple<int, string, GOddEvenComparable>(4, "A", new GOddEvenComparable(7));
            triple6 = new Triple<int, string, GOddEvenComparable>(4, "A", new GOddEvenComparable(2));
            Assert.IsTrue(triple5.CompareTo(triple6) < 0);
            Assert.IsFalse(triple5.Equals(triple6));
            Assert.IsFalse(triple5.GetHashCode() == triple6.GetHashCode());

            triple5 = new Triple<int, string, GOddEvenComparable>(4, "A", new GOddEvenComparable(7));
            triple6 = new Triple<int, string, GOddEvenComparable>(4, "A", new GOddEvenComparable(7));
            Assert.IsTrue(triple5.CompareTo(triple6) == 0);
            Assert.IsTrue(triple5.Equals(triple6));
            Assert.IsTrue(triple5.GetHashCode() == triple6.GetHashCode());

            triple5 = new Triple<int, string, GOddEvenComparable>(7, "B", new GOddEvenComparable(7));
            triple6 = new Triple<int, string, GOddEvenComparable>(4, "C", new GOddEvenComparable(2));
            Assert.IsTrue(triple5.CompareTo(triple6) > 0);
            Assert.IsFalse(triple5.Equals(triple6));
            Assert.IsFalse(triple5.GetHashCode() == triple6.GetHashCode());

            triple5 = new Triple<int, string, GOddEvenComparable>(0, "A", new GOddEvenComparable(8));
            triple6 = new Triple<int, string, GOddEvenComparable>(0, "A", new GOddEvenComparable(2));
            Assert.IsTrue(triple5.CompareTo(triple6) > 0);
            Assert.IsFalse(triple5.Equals(triple6));
            Assert.IsFalse(triple5.GetHashCode() == triple6.GetHashCode());
        }

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

            dict1[new Triple<string, int, double>("foo", 12, 3.14)] = "hello";
            dict1[new Triple<string, int, double>("zebra", 1, 2.4)] = "long";
            dict1[new Triple<string, int, double>("zebra", 1, 9.1)] = "strange";
            dict1[new Triple<string, int, double>("zzz", 14, 8.3)] = "trip";
            dict1[new Triple<string, int, double>("foo", 16, 0.0)] = "goodbye";
            dict1[new Triple<string, int, double>("foo", 12, 3.14)] = "another";

            string[] s_array = { "another", "goodbye", "long", "strange", "trip" };

            Assert.AreEqual(5, dict1.Count);
            int i = 0;
            foreach (string s in dict1.Values) {
                Assert.AreEqual(s_array[i], s);
                ++i;
            }
        }

        [Test]
        public void IComparable()
        {
            Triple<int, GOddEvenComparable, string> triple1, triple2;
            IComparable comp;
            object o;

            triple1 = new Triple<int, GOddEvenComparable, string>(4, new GOddEvenComparable(7), "B");
            triple2 = new Triple<int, GOddEvenComparable, string>(7, new GOddEvenComparable(3), "A");
            comp = triple1;
            o = triple2;
            Assert.IsTrue(comp.CompareTo(o) < 0);

            triple1 = new Triple<int, GOddEvenComparable, string>(4, new GOddEvenComparable(7), "B");
            triple2 = new Triple<int, GOddEvenComparable, string>(4, new GOddEvenComparable(2), "A");
            comp = triple1;
            o = triple2;
            Assert.IsTrue(comp.CompareTo(o) < 0);

            triple1 = new Triple<int, GOddEvenComparable, string>(4, new GOddEvenComparable(7), "A");
            triple2 = new Triple<int, GOddEvenComparable, string>(4, new GOddEvenComparable(7), "A");
            comp = triple1;
            o = triple2;
            Assert.IsTrue(comp.CompareTo(o) == 0);

            triple1 = new Triple<int, GOddEvenComparable, string>(7, new GOddEvenComparable(7), "B");
            triple2 = new Triple<int, GOddEvenComparable, string>(4, new GOddEvenComparable(2), "C");
            comp = triple1;
            o = triple2;
            Assert.IsTrue(comp.CompareTo(o) > 0);

            try {
                int i = comp.CompareTo("foo");
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is ArgumentException);
            }
        }

        [Test]
        public void Serialize()
        {
            Triple<int, string, string> p1 = new Triple<int, string,string>(-12, "hello", "world");
            Triple<string, string, double> p2 = new Triple<string, string, double>("hi", "elvis", 11);
            Triple<int, string,string> s1 = (Triple<int, string,string>)InterfaceTests.SerializeRoundTrip(p1);
            Triple<string, string, double> s2 = (Triple<string, string, double>)InterfaceTests.SerializeRoundTrip(p2);
            Assert.AreEqual(p1, s1);
            Assert.AreEqual(p2, s2);
        }
    }
}