listbasetests.cs

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

            try {
                range = list.Range(100, 1);
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is ArgumentOutOfRangeException);
                Assert.AreEqual("start", ((ArgumentOutOfRangeException)e).ParamName);
            }

            try {
                range = list.Range(int.MinValue, 1);
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is ArgumentOutOfRangeException);
                Assert.AreEqual("start", ((ArgumentOutOfRangeException)e).ParamName);
            }

            try {
                range = list.Range(int.MaxValue, 1);
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is ArgumentOutOfRangeException);
                Assert.AreEqual("start", ((ArgumentOutOfRangeException)e).ParamName);
            }
        }

        [Test]
        public void ReadOnlyRangeExceptions()
        {
            int[] array = new int[100];
            ReadOnlyArrayList<int> list = new ReadOnlyArrayList<int>(array);
            IList<int> range;

            try {
                range = list.Range(3, 98);
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is ArgumentOutOfRangeException);
                Assert.AreEqual("count", ((ArgumentOutOfRangeException)e).ParamName);
            }

            try {
                range = list.Range(-1, 1);
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is ArgumentOutOfRangeException);
                Assert.AreEqual("start", ((ArgumentOutOfRangeException)e).ParamName);
            }

            try {
                range = list.Range(0, int.MaxValue);
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is ArgumentOutOfRangeException);
                Assert.AreEqual("count", ((ArgumentOutOfRangeException)e).ParamName);
            }

            try {
                range = list.Range(1, int.MinValue);
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is ArgumentOutOfRangeException);
                Assert.AreEqual("count", ((ArgumentOutOfRangeException)e).ParamName);
            }

            try {
                range = list.Range(45, int.MinValue);
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is ArgumentOutOfRangeException);
                Assert.AreEqual("count", ((ArgumentOutOfRangeException)e).ParamName);
            }

            try {
                range = list.Range(0, 101);
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is ArgumentOutOfRangeException);
                Assert.AreEqual("count", ((ArgumentOutOfRangeException)e).ParamName);
            }

            try {
                range = list.Range(100, 1);
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is ArgumentOutOfRangeException);
                Assert.AreEqual("start", ((ArgumentOutOfRangeException)e).ParamName);
            }

            try {
                range = list.Range(int.MinValue, 1);
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is ArgumentOutOfRangeException);
                Assert.AreEqual("start", ((ArgumentOutOfRangeException)e).ParamName);
            }

            try {
                range = list.Range(int.MaxValue, 1);
                Assert.Fail("should throw");
            }
            catch (Exception e) {
                Assert.IsTrue(e is ArgumentOutOfRangeException);
                Assert.AreEqual("start", ((ArgumentOutOfRangeException)e).ParamName);
            }
        }

        [Test]
        public void AsReadOnly()
        {
            int[] elements = new int[400];
            for (int i = 0; i < 400; ++i)
                elements[i] = i;

            ReadWriteArrayList<int> list1 = new ReadWriteArrayList<int>(elements);
            IList<int> list2 = list1.AsReadOnly();

            InterfaceTests.TestReadOnlyListGeneric<int>(list2, elements, null);

            list1.Add(27);
            list1.Insert(0, 98);
            list1[17] = 9;

            elements = new int[402];
            list2 = list1.AsReadOnly();

            for (int i = 0; i < 401; ++i)
                elements[i] = i - 1;

            elements[0] = 98;
            elements[401] = 27;
            elements[17] = 9;

            InterfaceTests.TestReadOnlyListGeneric<int>(list2, elements, null);

            list1 = new ReadWriteArrayList<int>(new int[0]);
            list2 = list1.AsReadOnly();
            InterfaceTests.TestReadOnlyListGeneric<int>(list2, new int[0], null);
            list1.Add(4);
            InterfaceTests.TestReadOnlyListGeneric<int>(list2, new int[] { 4 }, null);
        }

        private void CheckArray<T>(T[] actual, T[] expected)
        {
            Assert.AreEqual(expected.Length, actual.Length);
            for (int i = 0; i < actual.Length; ++i) {
                Assert.AreEqual(expected[i], actual[i]);
            }
        }

        [Test]
        public void CopyTo1()
        {
            string[] array1 = { "foo", "bar", "baz", "smell", "the", "glove" };
            ReadWriteArrayList<string> list1 = new ReadWriteArrayList<string>(new string[] { "hello", "Sailor" });
            list1.CopyTo(array1);
            CheckArray<string>(array1, new string[] { "hello", "Sailor", "baz", "smell", "the", "glove" });

            ReadWriteArrayList<string> list2 = new ReadWriteArrayList<string>(new string[0]);
            list2.CopyTo(array1);
            CheckArray<string>(array1, new string[] { "hello", "Sailor", "baz", "smell", "the", "glove" });

            ReadWriteArrayList<string> list3 = new ReadWriteArrayList<string>(new string[] { "a1", "a2", "a3", "a4" });
            list3.CopyTo(array1);
            CheckArray<string>(array1, new string[] { "a1", "a2", "a3", "a4", "the", "glove" });

            ReadWriteArrayList<string> list4 = new ReadWriteArrayList<string>(new string[] { "b1", "b2", "b3", "b4", "b5", "b6" });
            list4.CopyTo(array1);
            CheckArray<string>(array1, new string[] { "b1", "b2", "b3", "b4", "b5", "b6" });

            list1.CopyTo(array1);
            CheckArray<string>(array1, new string[] { "hello", "Sailor", "b3", "b4", "b5", "b6" });

            ReadWriteArrayList<string> list5 = new ReadWriteArrayList<string>(new string[0]);
            string[] array2 = new string[0];
            list5.CopyTo(array2);
            CheckArray<string>(array2, new string[] { });
        }

        [Test]
        public void CopyTo2()
        {
            string[] array1 = { "foo", "bar", "baz", "smell", "the", "glove" };
            ReadWriteArrayList<string> list1 = new ReadWriteArrayList<string>(new string[] { "hello", "Sailor" });
            list1.CopyTo(array1, 3);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "hello", "Sailor", "glove" });

            ReadWriteArrayList<string> list2 = new ReadWriteArrayList<string>(new string[0]);
            list2.CopyTo(array1, 1);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "hello", "Sailor", "glove" });

            ReadWriteArrayList<string> list3 = new ReadWriteArrayList<string>(new string[] { "a1", "a2", "a3", "a4" });
            list3.CopyTo(array1, 2);
            CheckArray<string>(array1, new string[] { "foo", "bar", "a1", "a2", "a3", "a4" });

            ReadWriteArrayList<string> list4 = new ReadWriteArrayList<string>(new string[] { "b1", "b2", "b3", "b4", "b5", "b6" });
            list4.CopyTo(array1, 0);
            CheckArray<string>(array1, new string[] { "b1", "b2", "b3", "b4", "b5", "b6" });

            list1.CopyTo(array1, 4);
            CheckArray<string>(array1, new string[] { "b1", "b2", "b3", "b4", "hello", "Sailor" });

            ReadWriteArrayList<string> list5 = new ReadWriteArrayList<string>(new string[0]);
            string[] array2 = new string[0];
            list5.CopyTo(array2, 0);
            CheckArray<string>(array2, new string[] { });
        }

        [Test]
        public void CopyTo3()
        {
            string[] array1 = { "foo", "bar", "baz", "smell", "the", "glove" };
            ReadWriteArrayList<string> list1 = new ReadWriteArrayList<string>(new string[] { "hello", "Sailor" });
            list1.CopyTo(1, array1, 3, 1);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "Sailor", "the", "glove" });
            list1.CopyTo(0, array1, 5, 1);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "Sailor", "the", "hello" });
            list1.CopyTo(2, array1, 6, 0);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "Sailor", "the", "hello" });

            ReadWriteArrayList<string> list2 = new ReadWriteArrayList<string>(new string[0]);
            list2.CopyTo(0, array1, 1, 0);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "Sailor", "the", "hello" });
            list2.CopyTo(0, array1, 0, 0);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "Sailor", "the", "hello" });
            list2.CopyTo(0, array1, 6, 0);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "Sailor", "the", "hello" });

            ReadWriteArrayList<string> list3 = new ReadWriteArrayList<string>(new string[] { "a1", "a2", "a3", "a4" });
            list3.CopyTo(1, array1, 4, 2);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "Sailor", "a2", "a3" });

            ReadWriteArrayList<string> list4 = new ReadWriteArrayList<string>(new string[] { "b1", "b2", "b3", "b4", "b5", "b6" });
            list4.CopyTo(0, array1, 0, 6);
            CheckArray<string>(array1, new string[] { "b1", "b2", "b3", "b4", "b5", "b6" });

            ReadWriteArrayList<string> list5 = new ReadWriteArrayList<string>(new string[0]);
            string[] array2 = new string[0];
            list5.CopyTo(0, array2, 0, 0);
            CheckArray<string>(array2, new string[] { });
        }


        [Test]
        public void CopyTo1ReadOnly()
        {
            string[] array1 = { "foo", "bar", "baz", "smell", "the", "glove" };
            ReadOnlyArrayList<string> list1 = new ReadOnlyArrayList<string>(new string[] { "hello", "Sailor" });
            list1.CopyTo(array1);
            CheckArray<string>(array1, new string[] { "hello", "Sailor", "baz", "smell", "the", "glove" });

            ReadOnlyArrayList<string> list2 = new ReadOnlyArrayList<string>(new string[0]);
            list2.CopyTo(array1);
            CheckArray<string>(array1, new string[] { "hello", "Sailor", "baz", "smell", "the", "glove" });

            ReadOnlyArrayList<string> list3 = new ReadOnlyArrayList<string>(new string[] { "a1", "a2", "a3", "a4" });
            list3.CopyTo(array1);
            CheckArray<string>(array1, new string[] { "a1", "a2", "a3", "a4", "the", "glove" });

            ReadOnlyArrayList<string> list4 = new ReadOnlyArrayList<string>(new string[] { "b1", "b2", "b3", "b4", "b5", "b6" });
            list4.CopyTo(array1);
            CheckArray<string>(array1, new string[] { "b1", "b2", "b3", "b4", "b5", "b6" });

            list1.CopyTo(array1);
            CheckArray<string>(array1, new string[] { "hello", "Sailor", "b3", "b4", "b5", "b6" });

            ReadOnlyArrayList<string> list5 = new ReadOnlyArrayList<string>(new string[0]);
            string[] array2 = new string[0];
            list5.CopyTo(array2);
            CheckArray<string>(array2, new string[] { });
        }

        [Test]
        public void CopyTo2ReadOnly()
        {
            string[] array1 = { "foo", "bar", "baz", "smell", "the", "glove" };
            ReadOnlyArrayList<string> list1 = new ReadOnlyArrayList<string>(new string[] { "hello", "Sailor" });
            list1.CopyTo(array1, 3);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "hello", "Sailor", "glove" });

            ReadOnlyArrayList<string> list2 = new ReadOnlyArrayList<string>(new string[0]);
            list2.CopyTo(array1, 1);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "hello", "Sailor", "glove" });

            ReadOnlyArrayList<string> list3 = new ReadOnlyArrayList<string>(new string[] { "a1", "a2", "a3", "a4" });
            list3.CopyTo(array1, 2);
            CheckArray<string>(array1, new string[] { "foo", "bar", "a1", "a2", "a3", "a4" });

            ReadOnlyArrayList<string> list4 = new ReadOnlyArrayList<string>(new string[] { "b1", "b2", "b3", "b4", "b5", "b6" });
            list4.CopyTo(array1, 0);
            CheckArray<string>(array1, new string[] { "b1", "b2", "b3", "b4", "b5", "b6" });

            list1.CopyTo(array1, 4);
            CheckArray<string>(array1, new string[] { "b1", "b2", "b3", "b4", "hello", "Sailor" });

            ReadOnlyArrayList<string> list5 = new ReadOnlyArrayList<string>(new string[0]);
            string[] array2 = new string[0];
            list5.CopyTo(array2, 0);
            CheckArray<string>(array2, new string[] { });
        }

        [Test]
        public void CopyTo3ReadOnly()
        {
            string[] array1 = { "foo", "bar", "baz", "smell", "the", "glove" };
            ReadOnlyArrayList<string> list1 = new ReadOnlyArrayList<string>(new string[] { "hello", "Sailor" });
            list1.CopyTo(1, array1, 3, 1);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "Sailor", "the", "glove" });
            list1.CopyTo(0, array1, 5, 1);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "Sailor", "the", "hello" });
            list1.CopyTo(2, array1, 6, 0);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "Sailor", "the", "hello" });

            ReadOnlyArrayList<string> list2 = new ReadOnlyArrayList<string>(new string[0]);
            list2.CopyTo(0, array1, 1, 0);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "Sailor", "the", "hello" });
            list2.CopyTo(0, array1, 0, 0);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "Sailor", "the", "hello" });
            list2.CopyTo(0, array1, 6, 0);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "Sailor", "the", "hello" });

            ReadOnlyArrayList<string> list3 = new ReadOnlyArrayList<string>(new string[] { "a1", "a2", "a3", "a4" });
            list3.CopyTo(1, array1, 4, 2);
            CheckArray<string>(array1, new string[] { "foo", "bar", "baz", "Sailor", "a2", "a3" });

            ReadOnlyArrayList<string> list4 = new ReadOnlyArrayList<string>(new string[] { "b1", "b2", "b3", "b4", "b5", "b6" });
            list4.CopyTo(0, array1, 0, 6);
            CheckArray<string>(array1, new string[] { "b1", "b2", "b3", "b4", "b5", "b6" });

            ReadOnlyArrayList<string> list5 = new ReadOnlyArrayList<string>(new string[0]);
            string[] array2 = new string[0];
            list5.CopyTo(0, array2, 0, 0);
            CheckArray<string>(array2, new string[] { });
        }