示例#1
0
        public static void Step3()
        {
            Comparator8258 comparator8258 = new Comparator8258();
            int            result         = comparator8258.Compare(17, -5);

            Console.WriteLine(result);
        }
示例#2
0
        public static void Step5()
        {
            List <int> integers = new List <int>()
            {
                -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
            };
            Comparator8258 comparator8258 = new Comparator8258();

            integers.Sort(comparator8258);
            Console.WriteLine(String.Join(", ", integers));
        }
        public void Comparator8258Test()
        {
            Comparator8258 comparator = new Comparator8258();

            Assert.AreEqual(-1, comparator.Compare(5, 10));
            Assert.AreEqual(1, comparator.Compare(10, 5));
            Assert.AreEqual(-1, comparator.Compare(4, 20));
            Assert.AreEqual(1, comparator.Compare(50, 20));
            Assert.AreEqual(0, comparator.Compare(15, 15));
            Assert.AreEqual(0, comparator.Compare(5, 7));
        }
示例#4
0
        public static void Step4()
        {
            List <int> integers = new List <int>();

            integers.Add(1);
            integers.Add(10);
            integers.Add(3);
            integers.Add(7);
            Comparator8258 comparator8258 = new Comparator8258();

            integers.Sort(comparator8258);
            Console.WriteLine(String.Join(", ", integers));
        }
示例#5
0
        public void CComparator8258SortTest()
        {
            List <int> expected = new List <int>()
            {
                7, 3, 10, 1
            };

            List <int> actual = new List <int>()
            {
                1, 3, 7, 10
            };
            Comparator8258 cmp = new Comparator8258();

            actual.Sort(cmp);
            CollectionAssert.AreEqual(actual, expected);

            List <int> expected1 = new List <int>()
            {
                6, 5, 7, 4, 8, 3, 9, 2, 10, 1, 0, -1, -2, -3, -4, -5
            };

            List <int> actual1 = new List <int>()
            {
                -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
            };
            Comparator8258 cmp1 = new Comparator8258();

            actual1.Sort(cmp1);
            CollectionAssert.AreEqual(actual1, expected1);

            List <int> expected2 = new List <int>()
            {
                5, 5, 5, 5, 5
            };

            List <int> actual2 = new List <int>()
            {
                5, 5, 5, 5, 5
            };
            Comparator8258 cmp2 = new Comparator8258();

            actual2.Sort(cmp2);
            CollectionAssert.AreEqual(actual2, expected2);
        }
示例#6
0
        static void Main(string[] args)
        {
            Comparator8258 comparator8258 = new Comparator8258();


            List <int> list = new List <int>();

            list.Add(1);
            list.Add(3);
            list.Add(7);
            list.Add(10);

            comparator8258.l = 10;
            list.Sort(comparator8258);
            int result = comparator8258.Compare(1, 10);

            Console.WriteLine(result);
            Console.WriteLine(String.Join(",", list));
        }
示例#7
0
        public void Comparator8258Test()
        {
            int            res;
            Comparator8258 p = new Comparator8258();

            res = p.Compare(5, 10);
            Assert.AreEqual(-1, res);

            res = p.Compare(10, 5);
            Assert.AreEqual(1, res);

            res = p.Compare(4, 20);
            Assert.AreEqual(-1, res);

            res = p.Compare(50, 20);
            Assert.AreEqual(1, res);

            res = p.Compare(15, 15);
            Assert.AreEqual(0, res);

            res = p.Compare(5, 7);
            Assert.AreEqual(0, res);
        }
        public void Comparator8258SortTest()
        {
            List <int>     expected, actual;
            Comparator8258 cmp = new Comparator8258();

            expected = new List <int>()
            {
                7, 3, 10, 1
            };
            actual = new List <int>()
            {
                1, 3, 7, 10
            };
            actual.Sort(cmp);
            CollectionAssert.AreEqual(expected, actual);
            expected = new List <int>()
            {
                6, 5, 7, 4, 8, 3, 9, 2, 10, 1, 0, -1, -2, -3, -4, -5
            };
            actual = new List <int>()
            {
                -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
            };
            actual.Sort(cmp);
            CollectionAssert.AreEqual(expected, actual);
            expected = new List <int>()
            {
                5, 5, 5, 5, 5
            };
            actual = new List <int>()
            {
                5, 5, 5, 5, 5
            };
            actual.Sort(cmp);
            CollectionAssert.AreEqual(expected, actual);
        }