public abstract Class Abstract2DArrayAssert<SELF extends Abstract2DArrayAssert<SELF, ACTUAL, ELEMENT>, ACTUAL, ELEMENT>

Class Inheritance

extends AbstractAssert<SELF extends Abstract2DArrayAssert<SELF, ACTUAL, ELEMENT>, ACTUAL>
implements Array2DAssert<SELF extends Abstract2DArrayAssert<SELF, ACTUAL, ELEMENT>, ELEMENT>

java.lang.Object
org.assertj.core.api.AbstractAssert
org.assertj.core.api.Abstract2DArrayAssert

All Implemented Interfaces

org.assertj.core.api.Array2DAssert

Known Direct Subclasses

org.assertj.core.api.Float2DArrayAssert, org.assertj.core.api.Int2DArrayAssert, org.assertj.core.api.Object2DArrayAssert, org.assertj.core.api.Boolean2DArrayAssert, org.assertj.core.api.Short2DArrayAssert, org.assertj.core.api.Byte2DArrayAssert, org.assertj.core.api.Char2DArrayAssert, org.assertj.core.api.Long2DArrayAssert, org.assertj.core.api.Double2DArrayAssert

Type Parameters

<SELF>: the "self" type of this assertion class.
<ACTUAL>: the type of the "actual" value which is a two-dimensional Array of ELEMENT.
<ELEMENT>: the type of the "actual" array element.

Base class for all two-dimensional array assertions.

Author: Maciej Wajcht
Since: 3.17.0

Field Summary

Inherited from org.assertj.core.api.AbstractAssert:: actual assertionErrorCreator conditions customRepresentation info myself objects printAssertionsDescription throwUnsupportedExceptionOnEquals

Constructor Summary

Access	Constructor and Description
protected	Abstract2DArrayAssert(final ACTUAL actual, final Class<?> selfType)

Method Summary

Modifier and Type	Method and Description
public abstract SELF	Returns: `this` assertion object. isDeepEqualTo(ACTUAL the given value to compare the actual value to. expected) Verifies that the actual 2D array is deeply equal to the given one.

Inherited from 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 isEqualTo 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 withAssertionState withFailMessage withFailMessage withRepresentation withThreadDumpOnError

Constructor Detail

Abstract2DArrayAssert	back to summary
protected Abstract2DArrayAssert(final ACTUAL actual, final Class<?> selfType)

Method Detail

isDeepEqualTo back to summary

isDeepEqualTo	back to summary
public abstract SELF isDeepEqualTo(ACTUAL expected) Verifies that the actual 2D array is deeply equal to the given one. Two arrays 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 int[][] {{1, 2}, {3, 4}}).isDeepEqualTo(new int[][] {{1, 2}, {3, 4}}); // assertions will fail assertThat(new int[][] {{1, 2}, {3, 4}}).isDeepEqualTo(new int[][] {{1, 2}, {9, 10}}); assertThat(new int[][] {{1, 2}, {3, 4}}).isDeepEqualTo(new int[][] {{1, 2, 3}, {4}});` Parameters expected:ACTUAL the given value to compare the actual value to. Returns:SELF `this` assertion object. Exceptions AssertionError: if the actual 2D array is not deeply equal to the given one.

public abstract SELF isDeepEqualTo(ACTUAL expected)

Verifies that the actual 2D array is deeply equal to the given one.

Two arrays 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 int[][] {{1, 2}, {3, 4}}).isDeepEqualTo(new int[][] {{1, 2}, {3, 4}});

// assertions will fail
assertThat(new int[][] {{1, 2}, {3, 4}}).isDeepEqualTo(new int[][] {{1, 2}, {9, 10}});
assertThat(new int[][] {{1, 2}, {3, 4}}).isDeepEqualTo(new int[][] {{1, 2, 3}, {4}});

Parameters

expected:ACTUAL: the given value to compare the actual value to.

Returns:SELF

this assertion object.

Exceptions

AssertionError:: if the actual 2D array is not deeply equal to the given one.