Beispiel #1
0
        public void JaggedArraySortByMaxElementsInRowsRowNullTest()
        {
            int[][]     data = { null,
                                 new int[1] {
                                     17
                                 },
                                 new int[3] {
                                     19, 22, 33
                                 } };
            JaggedArray jaggedArray = new JaggedArray(data);

            Assert.Throws <ArgumentNullException>(() => jaggedArray.SortRowsByMaxElementsInRows(false));
        }
Beispiel #2
0
        public void JaggedArraySortByMinElementsInRowsRowEmptyTest()
        {
            int[][]     data = { new int[3] {
                                     19, 22, 33
                                 },
                                 new int[0]     {
                                 },
                                 new int[3]     {
                                     19, 22, 33
                                 } };
            JaggedArray jaggedArray = new JaggedArray(data);

            Assert.Throws <ArgumentException>(() => jaggedArray.SortRowsByMinElementsInRows(false));
        }
Beispiel #3
0
        public void JaggedArraySortByMaxElementsInRowsTest4()
        {
            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
                                 } };
            JaggedArray jaggedArray = new JaggedArray(data);

            int[][] expected = { new int[4] {
                                     100, 100, -150, 88
                                 },
                                 new int[2] {
                                     -19, 22
                                 },
                                 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
                                 } };
            int[][] actual = jaggedArray.SortRowsByMaxElementsInRows(false);

            Assert.AreEqual(expected, actual);
        }
Beispiel #4
0
        public void JaggedArraySortByRowsSumsOverflowTest()
        {
            int[][]     data = { new int[5] {
                                     0, int.MaxValue, int.MaxValue, 0, 1
                                 },
                                 new int[5]     {
                                     0, int.MinValue, int.MinValue, 0, 0
                                 },
                                 new int[5]     {
                                     1, int.MaxValue, 2, 3, 0
                                 },
                                 new int[5]     {
                                     int.MinValue, 0, -11, 0, -11
                                 },
                                 new int[5]     {
                                     int.MaxValue, int.MinValue, int.MaxValue, int.MinValue, int.MaxValue
                                 } };
            JaggedArray jaggedArray = new JaggedArray(data);

            Assert.Throws <OverflowException>(() => jaggedArray.SortRowsByElementsSumInRows(true));
        }
Beispiel #5
0
        public void JaggedArraySortByMaxElementsInRowsTest6()
        {
            int[][]     data = { new int[5] {
                                     0, 0, 0, 0, 0
                                 },
                                 new int[3]     {
                                     0, 0, 0
                                 },
                                 new int[5]     {
                                     0, 0, 0, 0, 0
                                 },
                                 new int[2]     {
                                     0, 0
                                 },
                                 new int[5]     {
                                     0, 0, 0, 0, 0
                                 } };
            JaggedArray jaggedArray = new JaggedArray(data);

            int[][] expected = { new int[5] {
                                     0, 0, 0, 0, 0
                                 },
                                 new int[3] {
                                     0, 0, 0
                                 },
                                 new int[5] {
                                     0, 0, 0, 0, 0
                                 },
                                 new int[2] {
                                     0, 0
                                 },
                                 new int[5] {
                                     0, 0, 0, 0, 0
                                 } };
            int[][] actual = jaggedArray.SortRowsByMaxElementsInRows(false);

            Assert.AreEqual(expected, actual);
        }