Package org.assertj.core.api
Class Object2DArrayAssert<ELEMENT>
java.lang.Object
org.assertj.core.api.AbstractAssert<Object2DArrayAssert<ELEMENT>,ELEMENT[][]>
org.assertj.core.api.Abstract2DArrayAssert<Object2DArrayAssert<ELEMENT>,ELEMENT[][],ELEMENT>
org.assertj.core.api.Object2DArrayAssert<ELEMENT>
- Type Parameters:
ELEMENT
- the type of elements of the "actual" value.
- All Implemented Interfaces:
Array2DAssert<Object2DArrayAssert<ELEMENT>,
,ELEMENT> Assert<Object2DArrayAssert<ELEMENT>,
,ELEMENT[][]> Descriptable<Object2DArrayAssert<ELEMENT>>
,ExtensionPoints<Object2DArrayAssert<ELEMENT>,
ELEMENT[][]>
public class Object2DArrayAssert<ELEMENT>
extends Abstract2DArrayAssert<Object2DArrayAssert<ELEMENT>,ELEMENT[][],ELEMENT>
Assertion methods for two-dimensional arrays of objects.
To create an instance of this class, invoke
.Assertions.assertThat(Object[][])
- Since:
- 3.17.0
- Author:
- Maciej Wajcht
-
Field Summary
Fields inherited from class org.assertj.core.api.AbstractAssert
actual, info, myself, objects, throwUnsupportedExceptionOnEquals
-
Constructor Summary
-
Method Summary
Modifier and TypeMethodDescriptionVerifies that the actual ELEMENT[][] contains the given ELEMENT[] at the given index.doesNotContain
(ELEMENT[] value, Index index) Verifies that the actual ELEMENT[][] does not contain the given ELEMENT[] at the given index.hasDimensions
(int expectedFirstDimension, int expectedSecondDimension) Verifies that the actualELEMENT[][]
has the given dimensions.hasNumberOfRows
(int expected) Verifies that the actual two-dimensional array has the given number of rows.hasSameDimensionsAs
(Object array) Verifies that the actualELEMENT[][]
has the same dimensions as the given array.isDeepEqualTo
(ELEMENT[][] expected) Verifies that the actualELEMENT[][]
is deeply equal to the given one.void
isEmpty()
Verifies that the actualELEMENT[][]
is empty, empty means the array has no elements, said otherwise it can have any number of rows but all rows must be empty.Verifies that the actualELEMENT[][]
is equal to the given one.Verifies that the actualELEMENT[][]
is not empty, not empty means the array has at least one char element.void
Verifies that the actualELEMENT[][]
isnull
or empty, empty means the array has no elements, said otherwise it can have any number of rows but all rows must be empty.Methods inherited from class org.assertj.core.api.AbstractAssert
areEqual, asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, doesNotHaveSameHashCodeAs, doesNotHaveToString, doesNotHaveToString, equals, extracting, extracting, failure, failureWithActualExpected, failWithActualExpectedAndMessage, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, hasToString, inBinary, inHexadecimal, is, isElementOfCustomAssert, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, newListAssertInstance, overridingErrorMessage, overridingErrorMessage, satisfies, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, satisfiesAnyOfForProxy, satisfiesForProxy, setCustomRepresentation, setDescriptionConsumer, setPrintAssertionsDescription, throwAssertionError, usingComparator, usingComparator, usingDefaultComparator, usingRecursiveAssertion, usingRecursiveAssertion, usingRecursiveComparison, usingRecursiveComparison, withFailMessage, withFailMessage, withRepresentation, withThreadDumpOnError
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
Methods inherited from interface org.assertj.core.api.Descriptable
as, as, as, describedAs, describedAs
-
Field Details
-
object2dArrays
-
-
Constructor Details
-
Object2DArrayAssert
-
-
Method Details
-
isDeepEqualTo
Verifies that the actualELEMENT[][]
is deeply equal to the given one.Two array references are considered deeply equal if both are
null
or if they refer to arrays that contain the same number of elements and all corresponding pairs of elements in the two arrays are deeply equal.Example:
// assertion will pass assertThat(new String[][] {{"1", "2"}, {"3", "4"}}).isDeepEqualTo(new String[][] {{"1", "2"}, {"3", "4"}}); // assertions will fail assertThat(new String[][] {{"1", "2"}, {"3", "4"}}).isDeepEqualTo(new String[][] {{"1", "2"}, {"9", "0"}}); assertThat(new String[][] {{"1", "2"}, {"3", "4"}}).isDeepEqualTo(new String[][] {{"1", "2", "3"}, {"4"}});
- Specified by:
isDeepEqualTo
in classAbstract2DArrayAssert<Object2DArrayAssert<ELEMENT>,
ELEMENT[][], ELEMENT> - Parameters:
expected
- the given value to compare the actual value to.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actual value is not deeply equal to the given one.
-
isEqualTo
Verifies that the actualELEMENT[][]
is equal to the given one.WARNING! This method will use
equals
to compare (it will compare arrays references only).
Unless you specify a comparator withAbstractAssert.usingComparator(Comparator)
, it is advised to useisDeepEqualTo(Object[][])
instead.Example:
String[][] array = {{"1", "2"}, {"3", "4"}}; // assertion will pass assertThat(array).isEqualTo(array); // assertion will fail as isEqualTo calls equals which compares arrays references only. assertThat(array).isEqualTo(new String[][] {{"1", "2"}, {"3", "4"}});
- Specified by:
isEqualTo
in interfaceAssert<Object2DArrayAssert<ELEMENT>,
ELEMENT[][]> - Overrides:
isEqualTo
in classAbstractAssert<Object2DArrayAssert<ELEMENT>,
ELEMENT[][]> - Parameters:
expected
- the given value to compare the actualELEMENT[][]
to.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actualELEMENT[][]
is not equal to the given one.
-
isNullOrEmpty
public void isNullOrEmpty()Verifies that the actualELEMENT[][]
isnull
or empty, empty means the array has no elements, said otherwise it can have any number of rows but all rows must be empty.Example:
// assertions will pass String[][] array = null; assertThat(array).isNullOrEmpty(); assertThat(new String[][] { }).isNullOrEmpty(); assertThat(new String[][] { { } }).isNullOrEmpty(); // this is considered empty as there are no elements in the 2d array which is comprised of 3 empty rows. assertThat(new String[][] { { }, { }, { } }).isNullOrEmpty(); // assertion will fail assertThat(new String[][] { {'a'}, {'b'} }).isNullOrEmpty();
- Throws:
AssertionError
- if the actualELEMENT[][]
is notnull
or not empty.
-
isEmpty
public void isEmpty()Verifies that the actualELEMENT[][]
is empty, empty means the array has no elements, said otherwise it can have any number of rows but all rows must be empty.Example:
// assertions will pass assertThat(new String[][] { {} }).isEmpty(); // this is considered empty as there are no elements in the 2d array which is comprised of 3 empty rows. assertThat(new String[][] { { }, { }, { } }).isEmpty(); // assertions will fail assertThat(new String[][] { {'a'}, {'b'} }).isEmpty(); String[][] array = null; assertThat(array).isEmpty();
- Throws:
AssertionError
- if the actualELEMENT[][]
is not empty.
-
isNotEmpty
Verifies that the actualELEMENT[][]
is not empty, not empty means the array has at least one char element.Example:
// assertion will pass assertThat(new String[][] { {'a'}, {'b'} }).isNotEmpty(); assertThat(new String[][] { { }, {'b'} }).isNotEmpty(); // assertions will fail assertThat(new String[][] { }).isNotEmpty(); assertThat(new String[][] { { } }).isNotEmpty(); // this is considered empty as there are no elements in the 2d array which is comprised of 3 empty rows. assertThat(new String[][] { { }, { }, { } }).isNotEmpty(); String[][] array = null; assertThat(array).isNotEmpty();
- Returns:
this
assertion object.- Throws:
AssertionError
- if the actualELEMENT[][]
is empty or null.
-
hasDimensions
public Object2DArrayAssert<ELEMENT> hasDimensions(int expectedFirstDimension, int expectedSecondDimension) Verifies that the actualELEMENT[][]
has the given dimensions.Example:
// assertion will pass assertThat(new String[][] { {"1", "2", "3"}, {"4", "5", "6"} }).hasDimensions(2, 3); // assertions will fail assertThat(new String[][] { }).hasDimensions(1, 1); assertThat(new String[][] { {"1", "2", "3"}, {"4", "5", "6"} }).hasDimensions(3, 2); assertThat(new String[][] { {"1", "2", "3"}, {"4", "5", "6", "7"} }).hasDimensions(2, 3);
- Parameters:
expectedFirstDimension
- the expected number of values in first dimension of the actualELEMENT[][]
.expectedSecondDimension
- the expected number of values in second dimension of the actualELEMENT[][]
.- Returns:
this
assertion object.- Throws:
AssertionError
- if the number of values of the actualELEMENT[][]
is not equal to the given one.
-
hasNumberOfRows
Verifies that the actual two-dimensional array has the given number of rows.Example:
// 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);
- Parameters:
expected
- the expected number of rows of the two-dimensional array.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actual number of rows are not equal to the given one.
-
hasSameDimensionsAs
Verifies that the actualELEMENT[][]
has the same dimensions as the given array.Parameter is declared as Object to accept both Object and primitive arrays.
Example:String[][] stringArray = {{"a", "b", "c""}, {"d", "e", "f""}}; char[][] charArray = {{'a', 'b', 'c'}, {'d', 'e', 'f'}}; // assertion will pass assertThat(stringArray).hasSameDimensionsAs(charArray); // assertions will fail assertThat(stringArray).hasSameDimensionsAs(new char[][] {{'a', 'b'}, {'c', 'd'}, {'e', 'f'}}); assertThat(stringArray).hasSameDimensionsAs(new char[][] {{'a', 'b'}, {'c', 'd', 'e'}}); assertThat(stringArray).hasSameDimensionsAs(new char[][] {{'a', 'b', 'c'}, {'d', 'e'}});
- Parameters:
array
- the array to compare dimensions with actualELEMENT[][]
.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actualELEMENT[][]
isnull
.AssertionError
- if the array parameter isnull
or is not a true array.AssertionError
- if actualELEMENT[][]
and given array don't have the same dimensions.
-
contains
Verifies that the actual ELEMENT[][] contains the given ELEMENT[] at the given index.Example:
// assertion will pass assertThat(new String[][] {{"a", "b"}, {"c", "d"}}).contains(new String[] {"a", "b"}, atIndex(0)); // assertion will fail assertThat(new String[][] {{"a", "b"}, {"c", "d"}}).contains(new String[] {"a", "b"}, atIndex(1));
- Parameters:
value
- the value to look for.index
- the index where the value should be stored in the actual ELEMENT[][].- Returns:
- myself assertion object.
- Throws:
AssertionError
- if the actual ELEMENT[][] isnull
or empty.NullPointerException
- if the givenIndex
isnull
.IndexOutOfBoundsException
- if the value of the givenIndex
is equal to or greater than the size of the actual ELEMENT[][].AssertionError
- if the actual ELEMENT[][] does not contain the given value at the given index.
-
doesNotContain
Verifies that the actual ELEMENT[][] does not contain the given ELEMENT[] at the given index.Example:
// assertion will pass assertThat(new String[][] {{"a", "b"}, {"c", "d"}}).doesNotContain(new String[] {"a", "b"}, atIndex(1)); // assertion will fail assertThat(new String[][] {{"a", "b"}, {"c", "d"}}).doesNotContain(new String[] {"a", "b"}, atIndex(0));
- Parameters:
value
- the value to look for.index
- the index where the value should be stored in the actual ELEMENT[][].- Returns:
- myself assertion object.
- Throws:
AssertionError
- if the actual ELEMENT[][] isnull
.NullPointerException
- if the givenIndex
isnull
.AssertionError
- if the actual ELEMENT[][] contains the given value at the given index.
-