Add hasNumberOfRows to two-dimensional array assertions (assertj#2461)

Co-authored-by: Sekar Mylsamy <SekarMylsamy@users.noreply.github.com>

Author: 2 people

src/main/java/org/assertj/core/api/Array2DAssert.java

@@ -13,7 +13,7 @@
 package org.assertj.core.api;
 
 /**
- * Assertions applicable to two-dimensional arrays,
+ * Assertions applicable to two-dimensional arrays.
  *
  * @param <SELF> the "self" type of this assertion class. Please read &quot;<a href="http://bit.ly/1IZIRcY"
  *          target="_blank">Emulating
@@ -104,6 +104,25 @@ public interface Array2DAssert<SELF extends Array2DAssert<SELF, ELEMENT>, ELEMEN
    */
   SELF hasDimensions(int expectedFirstDimension, int expectedSecondDimension);
 
+  /**
+   * Verifies that the actual two-dimensional array has the given number of rows.
+   * <p>
+   * Example:
+   * <pre><code class='java'> // assertion will pass
+   * assertThat(new int[][] {{1, 2, 3}, {4, 5, 6}}).hasNumberOfRows(2);
+   * assertThat(new int[][] {{1}, {1, 2}, {1, 2, 3}}).hasNumberOfRows(3);
+   *
+   * // assertions will fail
+   * assertThat(new int[][] { }).hasNumberOfRows(1);
+   * assertThat(new int[][] {{1, 2, 3}, {4, 5, 6}}).hasNumberOfRows(3);
+   * assertThat(new int[][] {{1, 2, 3}, {4, 5, 6, 7}}).hasNumberOfRows(1); </code></pre>
+   *
+   * @param expected the expected number of rows of the two-dimensional array.
+   * @return {@code this} assertion object.
+   * @throws AssertionError if the actual number of rows are not equal to the given one.
+   */
+  SELF hasNumberOfRows(int expected);
+
   /**
    * Verifies that the actual array has the same dimensions as the given array.
    * <p>

src/main/java/org/assertj/core/api/Boolean2DArrayAssert.java

@@ -211,6 +211,29 @@ public Boolean2DArrayAssert hasDimensions(int expectedFirstDimension, int expect
     return myself;
   }
 
+  /**
+   * Verifies that the actual two-dimensional array has the given number of rows.
+   * <p>
+   * Example:
+   * <pre><code class='java'> // assertion will pass
+   * assertThat(new boolean[][] {{true, true, true}, {false, false, false}}).hasNumberOfRows(2);
+   * assertThat(new boolean[][] {{true}, {true, false}, {true, false, false}}).hasNumberOfRows(3);
+   *
+   * // assertions will fail
+   * assertThat(new boolean[][] { }).hasNumberOfRows(1);
+   * assertThat(new boolean[][] {{true, true, true}, {false, false, false}}).hasNumberOfRows(3);
+   * assertThat(new boolean[][] {{true, true, true}, {false, false, false, false}}).hasNumberOfRows(1); </code></pre>
+   *
+   * @param expected the expected number of rows of the two-dimensional array.
+   * @return {@code this} assertion object.
+   * @throws AssertionError if the actual number of rows are not equal to the given one.
+   */
+  @Override
+  public Boolean2DArrayAssert hasNumberOfRows(int expected) {
+    boolean2dArrays.assertNumberOfRows(info, actual, expected);
+    return myself;
+  }
+
   /**
    * Verifies that the actual {@code boolean[][]} has the same dimensions as the given array.
    * <p>

src/main/java/org/assertj/core/api/Byte2DArrayAssert.java

@@ -212,6 +212,30 @@ public Byte2DArrayAssert hasDimensions(int expectedFirstDimension, int expectedS
     return myself;
   }
 
+  /**
+   * Verifies that the actual two-dimensional array has the given number of rows.
+   * <p>
+   * Example:
+   * <pre><code class='java'> // assertion will pass
+   * assertThat(new byte[][] {{1, 2, 3}, {4, 5, 6}}).hasNumberOfRows(2);
+   * assertThat(new byte[][] {{1}, {1, 2}, {1, 2, 3}}).hasNumberOfRows(3);
+   *
+   * // assertions will fail
+   * assertThat(new byte[][] { }).hasNumberOfRows(1);
+   * assertThat(new byte[][] {{1, 2, 3}, {4, 5, 6}}).hasNumberOfRows(3);
+   * assertThat(new byte[][] {{1, 2, 3}, {4, 5, 6, 7}}).hasNumberOfRows(1); </code></pre>
+   *
+   * @param expected the expected number of rows of the two-dimensional array.
+   * @return {@code this} assertion object.
+   * @throws AssertionError if the actual number of rows are not equal to the given one.
+   */
+  @Override
+  public Byte2DArrayAssert hasNumberOfRows(int expected) {
+    byte2dArrays.assertNumberOfRows(info, actual, expected);
+    return myself;
+  }
+
+
   /**
    * Verifies that the actual {@code byte[][]} has the same dimensions as the given array.
    * <p>

src/main/java/org/assertj/core/api/Char2DArrayAssert.java

@@ -212,6 +212,29 @@ public Char2DArrayAssert hasDimensions(int expectedFirstDimension, int expectedS
     return myself;
   }
 
+  /**
+   * Verifies that the actual two-dimensional array has the given number of rows.
+   * <p>
+   * Example:
+   * <pre><code class='java'> // assertion will pass
+   * assertThat(new char[][] {{'1', '2', '3'}, {'4', '5', '6'}}).hasNumberOfRows(2);
+   * assertThat(new char[][] {{'1'}, {'1', '2'}, {'1', '2', '3'}}).hasNumberOfRows(3);
+   *
+   * // assertions will fail
+   * assertThat(new char[][] { }).hasNumberOfRows(1);
+   * assertThat(new char[][] {{'1', '2', '3'}, {'4', '5', '6'}}).hasNumberOfRows(3);
+   * assertThat(new char[][] {{'1', '2', '3'}, {'4', '5', '6', '7'}}).hasNumberOfRows(1); </code></pre>
+   *
+   * @param expected the expected number of rows of the two-dimensional array.
+   * @return {@code this} assertion object.
+   * @throws AssertionError if the actual number of rows are not equal to the given one.
+   */
+  @Override
+  public Char2DArrayAssert hasNumberOfRows(int expected) {
+    char2dArrays.assertNumberOfRows(info, actual, expected);
+    return myself;
+  }
+
   /**
    * Verifies that the actual {@code char[][]} has the same dimensions as the given array.
    * <p>

src/main/java/org/assertj/core/api/Double2DArrayAssert.java

@@ -212,6 +212,29 @@ public Double2DArrayAssert hasDimensions(int expectedFirstDimension, int expecte
     return myself;
   }
 
+  /**
+   * Verifies that the actual two-dimensional array has the given number of rows.
+   * <p>
+   * Example:
+   * <pre><code class='java'> // assertion will pass
+   * assertThat(new double[][] {{1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}}).hasNumberOfRows(2);
+   * assertThat(new double[][] {{1.0}, {1.0, 2.0}, {1.0, 2.0, 3.0}}).hasNumberOfRows(3);
+   *
+   * // assertions will fail
+   * assertThat(new double[][] { }).hasNumberOfRows(1);
+   * assertThat(new double[][] {{1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}}).hasNumberOfRows(3);
+   * assertThat(new double[][] {{1.0, 2.0, 3.0}, {4.0, 5.0, 6.0, 7.0}}).hasNumberOfRows(1); </code></pre>
+   *
+   * @param expected the expected number of rows of the two-dimensional array.
+   * @return {@code this} assertion object.
+   * @throws AssertionError if the actual number of rows are not equal to the given one.
+   */
+  @Override
+  public Double2DArrayAssert hasNumberOfRows(int expected) {
+    double2dArrays.assertNumberOfRows(info, actual, expected);
+    return myself;
+  }
+
   /**
    * Verifies that the actual {@code double[][]} has the same dimensions as the given array.
    * <p>

src/main/java/org/assertj/core/api/Float2DArrayAssert.java

@@ -207,6 +207,29 @@ public Float2DArrayAssert hasDimensions(int expectedFirstDimension, int expected
     return myself;
   }
 
+  /**
+   * Verifies that the actual two-dimensional array has the given number of rows.
+   * <p>
+   * Example:
+   * <pre><code class='java'> // assertion will pass
+   * assertThat(new float[][] {{1.0f, 2.0f, 3.0f}, {4.0f, 5.0f, 6.0f}}).hasNumberOfRows(2);
+   * assertThat(new float[][] {{1.0f}, {1.0f, 2.0f}, {1.0f, 2.0f, 3.0f}}).hasNumberOfRows(3);
+   *
+   * // assertions will fail
+   * assertThat(new float[][] { }).hasNumberOfRows(1);
+   * assertThat(new float[][] {{1.0f, 2.0f, 3.0f}, {4.0f, 5.0f, 6.0f}}).hasNumberOfRows(3);
+   * assertThat(new float[][] {{1.0f, 2.0f, 3.0f}, {4.0f, 5.0f, 6.0f, 7.0f}}).hasNumberOfRows(1); </code></pre>
+   *
+   * @param expected the expected number of rows of the two-dimensional array.
+   * @return {@code this} assertion object.
+   * @throws AssertionError if the actual number of rows are not equal to the given one.
+   */
+  @Override
+  public Float2DArrayAssert hasNumberOfRows(int expected) {
+    float2dArrays.assertNumberOfRows(info, actual, expected);
+    return myself;
+  }
+
   /**
    * Verifies that the actual {@code float[][]} has the same dimensions as the given array.
    * <p>

src/main/java/org/assertj/core/api/Int2DArrayAssert.java

@@ -125,6 +125,30 @@ public Int2DArrayAssert hasDimensions(int expectedFirstDimension, int expectedSe
     return myself;
   }
 
+
+  /**
+   * Verifies that the actual two-dimensional array has the given number of rows.
+   * <p>
+   * Example:
+   * <pre><code class='java'> // assertion will pass
+   * assertThat(new int[][] {{1, 2, 3}, {4, 5, 6}}).hasNumberOfRows(2);
+   * assertThat(new int[][] {{1}, {1, 2}, {1, 2, 3}}).hasNumberOfRows(3);
+   *
+   * // assertions will fail
+   * assertThat(new int[][] { }).hasNumberOfRows(1);
+   * assertThat(new int[][] {{1, 2, 3}, {4, 5, 6}}).hasNumberOfRows(3);
+   * assertThat(new int[][] {{1, 2, 3}, {4, 5, 6, 7}}).hasNumberOfRows(1); </code></pre>
+   *
+   * @param expected the expected number of rows of the two-dimensional array.
+   * @return {@code this} assertion object.
+   * @throws AssertionError if the actual number of rows are not equal to the given one.
+   */
+  @Override
+  public Int2DArrayAssert hasNumberOfRows(int expected) {
+    int2dArrays.assertNumberOfRows(info, actual, expected);
+    return myself;
+  }
+
   /**
    * Verifies that the actual {@code int[][]} has the same dimensions as the given array.
    * <p>

src/main/java/org/assertj/core/api/Long2DArrayAssert.java

@@ -211,6 +211,29 @@ public Long2DArrayAssert hasDimensions(int expectedFirstDimension, int expectedS
     return myself;
   }
 
+  /**
+   * Verifies that the actual two-dimensional array has the given number of rows.
+   * <p>
+   * Example:
+   * <pre><code class='java'> // assertion will pass
+   * assertThat(new long[][] {{1, 2, 3}, {4, 5, 6}}).hasNumberOfRows(2);
+   * assertThat(new long[][] {{1}, {1, 2}, {1, 2, 3}}).hasNumberOfRows(3);
+   *
+   * // assertions will fail
+   * assertThat(new long[][] { }).hasNumberOfRows(1);
+   * assertThat(new long[][] {{1, 2, 3}, {4, 5, 6}}).hasNumberOfRows(3);
+   * assertThat(new long[][] {{1, 2, 3}, {4, 5, 6, 7}}).hasNumberOfRows(1); </code></pre>
+   *
+   * @param expected the expected number of rows of the two-dimensional array.
+   * @return {@code this} assertion object.
+   * @throws AssertionError if the actual number of rows are not equal to the given one.
+   */
+  @Override
+  public Long2DArrayAssert hasNumberOfRows(int expected) {
+    long2dArrays.assertNumberOfRows(info, actual, expected);
+    return myself;
+  }
+
   /**
    * Verifies that the actual {@code long[][]} has the same dimensions as the given array.
    * <p>

src/main/java/org/assertj/core/api/Object2DArrayAssert.java

@@ -214,6 +214,29 @@ public Object2DArrayAssert<ELEMENT> hasDimensions(int expectedFirstDimension, in
     return myself;
   }
 
+  /**
+   * Verifies that the actual two-dimensional array has the given number of rows.
+   * <p>
+   * Example:
+   * <pre><code class='java'> // assertion will pass
+   * assertThat(new String[][] {{"1", "2", "3"}, {"4", "5", "6"}}).hasNumberOfRows(2);
+   * assertThat(new String[][] {{"1"}, {"1", "2"}, {"1", "2", "3"}}).hasNumberOfRows(3);
+   *
+   * // assertions will fail
+   * assertThat(new String[][] { }).hasNumberOfRows(1);
+   * assertThat(new String[][] {{"1", "2", "3"}, {"4", "5", "6"}}).hasNumberOfRows(3);
+   * assertThat(new String[][] {{"1", "2", "3"}, {"4", "5", "6", "7"}}).hasNumberOfRows(1); </code></pre>
+   *
+   * @param expected the expected number of rows of the two-dimensional array.
+   * @return {@code this} assertion object.
+   * @throws AssertionError if the actual number of rows are not equal to the given one.
+   */
+  @Override
+  public Object2DArrayAssert<ELEMENT> hasNumberOfRows(int expected) {
+    object2dArrays.assertNumberOfRows(info, actual, expected);
+    return myself;
+  }
+
   /**
    * Verifies that the actual {@code ELEMENT[][]} has the same dimensions as the given array.
    * <p>

src/main/java/org/assertj/core/api/Short2DArrayAssert.java

@@ -210,6 +210,29 @@ public Short2DArrayAssert hasDimensions(int expectedFirstDimension, int expected
     return myself;
   }
 
+  /**
+   * Verifies that the actual two-dimensional array has the given number of rows.
+   * <p>
+   * Example:
+   * <pre><code class='java'> // assertion will pass
+   * assertThat(new short[][] {{1, 2, 3}, {4, 5, 6}}).hasNumberOfRows(2);
+   * assertThat(new short[][] {{1}, {1, 2}, {1, 2, 3}}).hasNumberOfRows(3);
+   *
+   * // assertions will fail
+   * assertThat(new short[][] { }).hasNumberOfRows(1);
+   * assertThat(new short[][] {{1, 2, 3}, {4, 5, 6}}).hasNumberOfRows(3);
+   * assertThat(new short[][] {{1, 2, 3}, {4, 5, 6, 7}}).hasNumberOfRows(1); </code></pre>
+   *
+   * @param expected the expected number of rows of the two-dimensional array.
+   * @return {@code this} assertion object.
+   * @throws AssertionError if the actual number of rows are not equal to the given one.
+   */
+  @Override
+  public Short2DArrayAssert hasNumberOfRows(int expected) {
+    short2dArrays.assertNumberOfRows(info, actual, expected);
+    return myself;
+  }
+
   /**
    * Verifies that the actual {@code short[][]} has the same dimensions as the given array.
    * <p>