Example #1
0
        public void JaggedArraySortByMaxElementsInRowsTest5()
        {
            int[][] data = { new int[7] {
                                 4, 5, 6, -13, -22, 33, -17
                             },
                             new int[7] {
                                 4, 5, 6, -13, -22, 33, -17
                             },
                             new int[7] {
                                 4, 5, 6, -13, -22, 33, -17
                             } };
            JaggedArrayOperations jaggedArray = new JaggedArrayOperations(data);

            int[][] expected = { new int[7] {
                                     4, 5, 6, -13, -22, 33, -17
                                 },
                                 new int[7] {
                                     4, 5, 6, -13, -22, 33, -17
                                 },
                                 new int[7] {
                                     4, 5, 6, -13, -22, 33, -17
                                 } };
            int[][] actual = jaggedArray.SortWithTheHelpOfComparator(new JaggedArrayOperations.AscendingOrder.MaxElementsInRowsComparator());

            Assert.AreEqual(expected, actual);
        }
Example #2
0
        public void JaggedArraySortByMaxElementsInRowsNullTest()
        {
            int[][] data = null;
            JaggedArrayOperations jaggedArray = new JaggedArrayOperations(data);

            Assert.Throws <ArgumentNullException>(() => jaggedArray.SortWithTheHelpOfComparator(new JaggedArrayOperations.AscendingOrder.MaxElementsInRowsComparator()));
        }
Example #3
0
        public void JaggedArraySortByMaxElementsInRowsTest2()
        {
            int[][] data = { new int[4] {
                                 4, 5, 6, 11
                             },
                             new int[2] {
                                 7, 9
                             },
                             new int[3] {
                                 1, 2, 6
                             } };
            JaggedArrayOperations jaggedArray = new JaggedArrayOperations(data);

            int[][] expected = { new int[4] {
                                     4, 5, 6, 11
                                 },
                                 new int[2] {
                                     7, 9
                                 },
                                 new int[3] {
                                     1, 2, 6
                                 } };
            int[][] actual = jaggedArray.SortWithTheHelpOfComparator(new JaggedArrayOperations.DescendingOrder.MaxElementsInRowsComparator());

            Assert.AreEqual(expected, actual);
        }
Example #4
0
        public void JaggedArraySortByRowsSumsEmptyTest()
        {
            int[][] data = { };
            JaggedArrayOperations jaggedArray = new JaggedArrayOperations(data);

            Assert.Throws <ArgumentException>(() => jaggedArray.SortWithTheHelpOfComparator(new JaggedArrayOperations.AscendingOrder.ElementsSumInRowsComparator()));
        }
Example #5
0
        public void JaggedArraySortByMaxElementsInRowsRowNullTest()
        {
            int[][] data = { null,
                             new int[1] {
                                 17
                             },
                             new int[3] {
                                 19, 22, 33
                             } };
            JaggedArrayOperations jaggedArray = new JaggedArrayOperations(data);

            Assert.Throws <ArgumentNullException>(() => jaggedArray.SortWithTheHelpOfComparator(new JaggedArrayOperations.DescendingOrder.MaxElementsInRowsComparator()));
        }
Example #6
0
        public void JaggedArraySortByRowsSumsTest3()
        {
            int[][] data =
            {
                new int[6] {
                    4, 5, 6, 11, 18, -11
                },
                new int[5] {
                    7, 9, 0, 5, 1
                },
                new int[6] {
                    1, 2, 6, 1, -1, 3
                },
                new int[1] {
                    5
                },
                new int[2] {
                    -19, 22
                },
                new int[4] {
                    100, 100, -150, 88
                }
            };
            JaggedArrayOperations jaggedArray = new JaggedArrayOperations(data);

            int[][] expected =
            {
                new int[2] {
                    -19, 22
                },
                new int[1] {
                    5
                },
                new int[6] {
                    1, 2, 6, 1, -1, 3
                },
                new int[5] {
                    7, 9, 0, 5, 1
                },
                new int[6] {
                    4, 5, 6, 11, 18, -11
                },
                new int[4] {
                    100, 100, -150, 88
                }
            };
            int[][] actual = jaggedArray.SortWithTheHelpOfComparator(new JaggedArrayOperations.AscendingOrder.ElementsSumInRowsComparator());

            Assert.AreEqual(expected, actual);
        }
Example #7
0
        public void JaggedArraySortByMinElementsInRowsRowEmptyTest()
        {
            int[][] data = { new int[3] {
                                 19, 22, 33
                             },
                             new int[0] {
                             },
                             new int[3] {
                                 19, 22, 33
                             } };
            JaggedArrayOperations jaggedArray = new JaggedArrayOperations(data);

            Assert.Throws <ArgumentException>(() => jaggedArray.SortWithTheHelpOfComparator(new JaggedArrayOperations.AscendingOrder.MinElementsInRowsComparator()));
        }
Example #8
0
        public void JaggedArraySortByRowsSumsTest6()
        {
            int[][] data =
            {
                new int[5] {
                    0, 0, 0, 0, 0
                },
                new int[3] {
                    11, 33, -44
                },
                new int[5] {
                    0, 0, 0, 0, 0
                },
                new int[2] {
                    -7, 7
                },
                new int[5] {
                    0, 0, 0, 0, 0
                }
            };
            JaggedArrayOperations jaggedArray = new JaggedArrayOperations(data);

            int[][] expected =
            {
                new int[5] {
                    0, 0, 0, 0, 0
                },
                new int[3] {
                    11, 33, -44
                },
                new int[5] {
                    0, 0, 0, 0, 0
                },
                new int[2] {
                    -7, 7
                },
                new int[5] {
                    0, 0, 0, 0, 0
                }
            };
            int[][] actual = jaggedArray.SortWithTheHelpOfComparator(new JaggedArrayOperations.DescendingOrder.ElementsSumInRowsComparator());

            Assert.AreEqual(expected, actual);
        }