Review markups. Changed assertion order, test names and position of Ignore in MatrixExercise. Changed Integer.valueOf to Integer.parseInt in Matrix. Changed String.split to using Pattern in Matrix.

exercises/matrix/src/example/java/Matrix.java

+import java.util.regex.Pattern;
+
 public class Matrix {
     private int[][] matrix;
+    private static Pattern spacePattern = Pattern.compile(" ");
+    private static Pattern newlinePattern = Pattern.compile("\\n");
 
     public Matrix(String matrixAsString) {
-        String[] rows = matrixAsString.split("\\n");
+        String[] rows = newlinePattern.split(matrixAsString);
         matrix = new int[rows.length][];
         for (int i = 0; i < rows.length; i++) {
-            String[] columnValues = rows[i].split(" ");
+            String[] columnValues = spacePattern.split(rows[i]);
             matrix[i] = new int[columnValues.length];
             for (int j = 0; j < columnValues.length; j++) {
-                matrix[i][j] = Integer.valueOf(columnValues[j]);
+                matrix[i][j] = Integer.parseInt(columnValues[j]);
             }
         }
     }

exercises/matrix/src/test/java/MatrixTest.java

         private Matrix matrix;
         private int[] firstRow;
 
-        @Parameterized.Parameters(name = "{index}: checking first row of matrix constructed with string \"{0}\".")
+        @Parameterized.Parameters(name = "{index}: checking first row of matrix constructed with string \n\"{0}\".")
         public static Collection<Object[]> data() {
             return Arrays.asList(new Object[][]{
                     {"0", new int[] {0}},
                     {"0 1", new int[] {0, 1}},
-                    {"0\\n1", new int[] {0}},
-                    {"0 1\\n2 3", new int[] {0, 1}},
-                    {"0 1 2\\n3 4 5\\n6 7 8", new int[] {0, 1, 2}}
+                    {  "0\n"
+                     + "1", new int[] {0}},
+                    {  "0 1\n"
+                     + "2 3", new int[] {0, 1}},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", new int[] {0, 1, 2}}
             });
         }
 
         public GetFirstRowTest(String matrixAsString, int[] firstRow) {
-            this.matrix = new Matrix(matrixAsString.replaceAll("\\\\n", "\n"));
+            this.matrix = new Matrix(matrixAsString);
             this.firstRow = firstRow;
         }
 
         @Test
         public void getFirstRowTest() {
-            assertArrayEquals(matrix.getRow(0), firstRow);
+            assertArrayEquals(firstRow, matrix.getRow(0));
         }
     }
 
+    @Ignore
     @RunWith(Parameterized.class)
     public static class GetLastRowTest {
         private Matrix matrix;
         private int[] lastRow;
 
-        @Parameterized.Parameters(name = "{index}: checking last row of matrix constructed with string \"{0}\".")
+        @Parameterized.Parameters(name = "{index}: checking last row of matrix constructed with string \n\"{0}\".")
         public static Collection<Object[]> data() {
             return Arrays.asList(new Object[][]{
                     {"0", new int[] {0}},
                     {"0 1", new int[] {0, 1}},
-                    {"0\\n1", new int[] {1}},
-                    {"0 1\\n2 3", new int[] {2, 3}},
-                    {"0 1 2\\n3 4 5\\n6 7 8", new int[] {6, 7, 8}}
+                    {  "0\n"
+                     + "1", new int[] {1}},
+                    {  "0 1\n"
+                     + "2 3", new int[] {2, 3}},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", new int[] {6, 7, 8}}
             });
         }
 
         public GetLastRowTest(String matrixAsString, int[] lastRow) {
-            this.matrix = new Matrix(matrixAsString.replaceAll("\\\\n", "\n"));
+            this.matrix = new Matrix(matrixAsString);
             this.lastRow = lastRow;
         }
 
-        @Ignore
         @Test
         public void getLastRowTest() {
-            assertArrayEquals(matrix.getRow(matrix.getRowsCount() - 1), lastRow);
+            assertArrayEquals(lastRow, matrix.getRow(matrix.getRowsCount() - 1));
         }
     }
 
+    @Ignore
     @RunWith(Parameterized.class)
     public static class GetFirstColumnTest {
         private Matrix matrix;
         private int[] firstColumn;
 
-        @Parameterized.Parameters(name = "{index}: checking first column of matrix constructed with string \"{0}\".")
+        @Parameterized.Parameters(name = "{index}: checking first column of matrix constructed with string \n\"{0}\".")
         public static Collection<Object[]> data() {
             return Arrays.asList(new Object[][]{
                     {"0", new int[] {0}},
                     {"0 1", new int[] {0}},
-                    {"0\\n1", new int[] {0, 1}},
-                    {"0 1\\n2 3", new int[] {0, 2}},
-                    {"0 1 2\\n3 4 5\\n6 7 8", new int[] {0, 3, 6}}
+                    {  "0\n"
+                     + "1", new int[] {0, 1}},
+                    {  "0 1\n"
+                     + "2 3", new int[] {0, 2}},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", new int[] {0, 3, 6}}
             });
         }
 
         public GetFirstColumnTest(String matrixAsString, int[] firstColumn) {
-            this.matrix = new Matrix(matrixAsString.replaceAll("\\\\n", "\n"));
+            this.matrix = new Matrix(matrixAsString);
             this.firstColumn = firstColumn;
         }
 
-        @Ignore
         @Test
         public void getFirstColumnTest() {
-            assertArrayEquals(matrix.getColumn(0), firstColumn);
+            assertArrayEquals(firstColumn, matrix.getColumn(0));
         }
     }
 
 
+    @Ignore
     @RunWith(Parameterized.class)
     public static class GetLastColumnTest {
         private Matrix matrix;
         private int[] lastColumn;
 
-        @Parameterized.Parameters(name = "{index}: checking last column of matrix constructed with string \"{0}\".")
+        @Parameterized.Parameters(name = "{index}: checking last column of matrix constructed with string \n\"{0}\".")
         public static Collection<Object[]> data() {
             return Arrays.asList(new Object[][]{
                     {"0", new int[] {0}},
                     {"0 1", new int[] {1}},
-                    {"0\\n1", new int[] {0, 1}},
-                    {"0 1\\n2 3", new int[] {1, 3}},
-                    {"0 1 2\\n3 4 5\\n6 7 8", new int[] {2, 5, 8}}
+                    {  "0\n"
+                     + "1", new int[] {0, 1}},
+                    {  "0 1\n"
+                     + "2 3", new int[] {1, 3}},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", new int[] {2, 5, 8}}
             });
         }
 
         public GetLastColumnTest(String matrixAsString, int[] lastColumn) {
-            this.matrix = new Matrix(matrixAsString.replaceAll("\\\\n", "\n"));
+            this.matrix = new Matrix(matrixAsString);
             this.lastColumn = lastColumn;
         }
 
-        @Ignore
         @Test
         public void getLastColumnTest() {
-            assertArrayEquals(matrix.getColumn(matrix.getColumnsCount() - 1), lastColumn);
+            assertArrayEquals(lastColumn, matrix.getColumn(matrix.getColumnsCount() - 1));
         }
     }
 
+    @Ignore
     @RunWith(Parameterized.class)
     public static class CountColumnsTest {
         private Matrix matrix;
         private int numberOfColumns;
 
-        @Parameterized.Parameters(name = "{index}: expected matrix constructed with string \"{0}\" to have {1} column(s).")
+        @Parameterized.Parameters(name = "{index}: expected matrix constructed with string \n\"{0}\" to have {1} column(s).")
         public static Collection<Object[]> data() {
             return Arrays.asList(new Object[][]{
                     {"0", 1},
                     {"0 1", 2},
-                    {"0\\n1", 1},
-                    {"0 1\\n2 3", 2},
-                    {"0 1 2\\n3 4 5\\n6 7 8", 3}
+                    {  "0\n"
+                     + "1", 1},
+                    {  "0 1\n"
+                     + "2 3", 2},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", 3}
             });
         }
 
         public CountColumnsTest(String matrixAsString, int numberOfColumns) {
-            this.matrix = new Matrix(matrixAsString.replaceAll("\\\\n", "\n"));
+            this.matrix = new Matrix(matrixAsString);
             this.numberOfColumns = numberOfColumns;
         }
 
-        @Ignore
         @Test
         public void countColumnsTest() {
-            assertEquals(matrix.getColumnsCount(), numberOfColumns);
+            assertEquals(numberOfColumns, matrix.getColumnsCount());
         }
     }
 
+    @Ignore
     @RunWith(Parameterized.class)
     public static class CountRowsTest {
         private Matrix matrix;
         private int numberOfRows;
 
-        @Parameterized.Parameters(name = "{index}: expected matrix constructed with string \"{0}\" to have {1} row(s).")
+        @Parameterized.Parameters(name = "{index}: expected matrix constructed with string \n\"{0}\" to have {1} row(s).")
         public static Collection<Object[]> data() {
             return Arrays.asList(new Object[][]{
                     {"0", 1},
                     {"0 1", 1},
-                    {"0\\n1", 2},
-                    {"0 1\\n2 3", 2},
-                    {"0 1 2\\n3 4 5\\n6 7 8", 3}
+                    {  "0\n"
+                     + "1", 2},
+                    {  "0 1\n"
+                     + "2 3", 2},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", 3}
             });
         }
 
         public CountRowsTest(String matrixAsString, int numberOfRows) {
-            this.matrix = new Matrix(matrixAsString.replaceAll("\\\\n", "\n"));
+            this.matrix = new Matrix(matrixAsString);
             this.numberOfRows = numberOfRows;
         }
 
-        @Ignore
         @Test
         public void countRowsTest() {
-            assertEquals(matrix.getRowsCount(), numberOfRows);
+            assertEquals(numberOfRows, matrix.getRowsCount());
         }
     }