public abstract Class AbstractLongArrayAssert<SELF extends AbstractLongArrayAssert<SELF>>

Verifies that the actual array contains the given values, in any order.

Example:

 // assertions will pass
assertThat(new long[] { 1L, 2L, 3L }).contains(1L, 2L);
assertThat(new long[] { 1L, 2L, 3L }).contains(3L, 1L);
assertThat(new long[] { 1L, 2L, 3L }).contains(1L, 3L, 2L);

// assertions will fail
assertThat(new long[] { 1L, 2L, 3L }).contains(1L, 4L);
assertThat(new long[] { 1L, 2L, 3L }).contains(4L, 7L);

Parameters

values:long[]

the given values.

Returns:SELF

this assertion object.

Exceptions

NullPointerException:

if the given argument is null.

AssertionError:

• if the given argument is an empty array and the actual array is not empty.
• if the actual array is null.
• if the actual array does not contain the given values.

Verifies that the actual array contains the values of the given array, in any order.

Example:

 // assertions will pass
assertThat(new long[] { 1L, 2L, 3L }).contains(new Long[] { 1L, 2L });
assertThat(new long[] { 1L, 2L, 3L }).contains(new Long[] { 3L, 1L });
assertThat(new long[] { 1L, 2L, 3L }).contains(new Long[] { 1L, 3L, 2L });

// assertions will fail
assertThat(new long[] { 1L, 2L, 3L }).contains(new Long[] { 1L, 4L });
assertThat(new long[] { 1L, 2L, 3L }).contains(new Long[] { 4L, 7L });

Parameters

values:Long[]

the given Long array of values.

Returns:SELF

this assertion object.

Exceptions

NullPointerException:

if the given argument is null.

AssertionError:

• if the given argument is an empty array and the actual array is not empty.
• if the actual array is null.
• if the actual array does not contain the given values.

Since

3.19.0

Verifies that the actual array contains the given value at the given index.

Example:

 // assertions will pass
assertThat(new long[] { 1L, 2L, 3L }).contains(1L, atIndex(O));
assertThat(new long[] { 1L, 2L, 3L }).contains(3L, atIndex(2));

// assertions will fail
assertThat(new long[] { 1L, 2L, 3L }).contains(1L, atIndex(1));
assertThat(new long[] { 1L, 2L, 3L }).contains(4L, atIndex(2));

Parameters

value:long

the value to look for.

index:Index

the index where the value should be stored in the actual array.

Returns:SELF

myself assertion object.

Exceptions

AssertionError:

• if the actual array is null or empty.
• if the actual array does not contain the given value at the given index.

NullPointerException:

if the given Index is null.

IndexOutOfBoundsException:

if the value of the given Index is equal to or greater than the size of the actual array.

Verifies that the actual array contains at least one of the given values.

Example :

 long[] oneTwoThree = { 1L, 2L, 3L };

// assertions will pass
assertThat(oneTwoThree).containsAnyOf(2L)
                       .containsAnyOf(2L, 3L)
                       .containsAnyOf(1L, 2L, 3L)
                       .containsAnyOf(1L, 2L, 3L, 4L)
                       .containsAnyOf(5L, 6L, 7L, 2L);

// assertions will fail
assertThat(oneTwoThree).containsAnyOf(4L);
assertThat(oneTwoThree).containsAnyOf(4L, 5L, 6L, 7L);

Parameters

values:long[]

the values whose at least one which is expected to be in the array under test.

Returns:SELF

this assertion object.

Exceptions

NullPointerException:

if the array of values is null.

AssertionError:

• if the array of values is empty and the array under test is not empty.
• if the array under test is null.
• if the array under test does not contain any of the given values.

Since

2.9.0 / 3.9.0

Verifies that the actual array contains at least one value of the given array.

Example :

 long[] oneTwoThree = { 1L, 2L, 3L };

// assertions will pass
assertThat(oneTwoThree).containsAnyOf(new Long[] { 2L })
                       .containsAnyOf(new Long[] { 2L, 3L })
                       .containsAnyOf(new Long[] { 1L, 2L, 3L })
                       .containsAnyOf(new Long[] { 1L, 2L, 3L, 4L })
                       .containsAnyOf(new Long[] { 5L, 6L, 7L, 2L });

// assertions will fail
assertThat(oneTwoThree).containsAnyOf(new Long[] { 4L });
assertThat(oneTwoThree).containsAnyOf(new Long[] { 4L, 5L, 6L, 7L });

Parameters

values:Long[]

the array of values whose at least one which is expected to be in the array under test.

Returns:SELF

this assertion object.

Exceptions

NullPointerException:

if the array of values is null.

AssertionError:

• if the array of values is empty and the array under test is not empty.
• if the array under test is null.
• if the array under test does not contain any of the given values.

Since

3.19.0

Verifies that the actual group contains only the given values and nothing else, in order.

Example :

 long[] longs = { 1, 2, 3 };

// assertion will pass
assertThat(longs).containsExactly(1, 2, 3);

// assertion will fail as actual and expected order differ
assertThat(longs).containsExactly(2, 1, 3);

Parameters

values:long[]

the given values.

Returns:SELF

this assertion object.

Exceptions

NullPointerException:

if the given argument is null.

AssertionError:

• if the actual group is null.
• if the given argument is an empty array and the actual array is not empty.
• if the actual group does not contain the given values with same order, i.e. the actual group contains some or none of the given values, or the actual group contains more values than the given ones or values are the same but the order is not.

Verifies that the actual group contains only the values of the given array and nothing else, in order.

Example :

 long[] longs = { 1, 2, 3 };

// assertion will pass
assertThat(longs).containsExactly(new Long[] { 1, 2, 3 });

// assertion will fail as actual and expected order differ
assertThat(longs).containsExactly(new Long[] { 2, 1, 3 });

Parameters

values:Long[]

the given values.

Returns:SELF

this assertion object.

Exceptions

NullPointerException:

if the given argument is null.

AssertionError:

• if the actual group is null.
• if the given argument is an empty array and the actual array is not empty.
• if the actual group does not contain the given values with same order, i.e. the actual group contains some or none of the given values, or the actual group contains more values than the given ones or values are the same but the order is not.

Since

3.19.0

Verifies that the actual group contains exactly the given values and nothing else, in any order.

Example :

 // assertions will pass
assertThat(new long[] { 1L, 2L }).containsExactlyInAnyOrder(1L, 2L);
assertThat(new long[] { 1L, 2L, 1L }).containsExactlyInAnyOrder(1L, 1L, 2L);

// assertions will fail
assertThat(new long[] { 1L, 2L }).containsExactlyInAnyOrder(1L);
assertThat(new long[] { 1L }).containsExactlyInAnyOrder(1L, 2L);
assertThat(new long[] { 1L, 2L, 1L }).containsExactlyInAnyOrder(1L, 2L);

Parameters

values:long[]

the given values.

Returns:SELF

this assertion object.

Exceptions

NullPointerException:

if the given argument is null.

AssertionError:

• if the actual group is null.
• if the given argument is an empty array and the actual array is not empty.
• if the actual group does not contain the given values, i.e. the actual group contains some or none of the given values, or the actual group contains more values than the given ones.

Since

2.6.0 / 3.6.0

Verifies that the actual group contains exactly the values of the given array and nothing else, in any order.

Example :

 // assertions will pass
assertThat(new long[] { 1L, 2L }).containsExactlyInAnyOrder(new Long[] { 1L, 2L });
assertThat(new long[] { 1L, 2L, 1L }).containsExactlyInAnyOrder(new Long[] { 1L, 1L, 2L });

// assertions will fail
assertThat(new long[] { 1L, 2L }).containsExactlyInAnyOrder(new Long[] { 1L });
assertThat(new long[] { 1L }).containsExactlyInAnyOrder(new Long[] { 1L, 2L });
assertThat(new long[] { 1L, 2L, 1L }).containsExactlyInAnyOrder(new Long[] { 1L, 2L });

Parameters

values:Long[]

the given values.

Returns:SELF

this assertion object.

Exceptions

NullPointerException:

if the given argument is null.

AssertionError:

• if the actual group is null.
• if the given argument is an empty array and the actual array is not empty.
• if the actual group does not contain the given values, i.e. the actual group contains some or none of the given values, or the actual group contains more values than the given ones.

Since

3.19.0

Verifies that the actual array contains only the given values and nothing else, in any order.

Example:

 // assertions will pass
assertThat(new long[] { 1L, 2L, 3L }).containsOnly(1L, 2L, 3L);
assertThat(new long[] { 1L, 2L, 3L }).containsOnly(2L, 3L, 1L);
assertThat(new long[] { 1L, 1L, 2L }).containsOnly(1L, 2L);

// assertions will fail
assertThat(new long[] { 1L, 2L, 3L }).containsOnly(1L, 2L, 3L, 4L);
assertThat(new long[] { 1L, 2L, 3L }).containsOnly(4L, 7L);

Parameters

values:long[]

the given values.

Returns:SELF

this assertion object.

Exceptions

NullPointerException:

if the given argument is null.

AssertionError:

• if the given argument is an empty array and the actual array is not empty.
• if the actual array is null.
• if the actual array does not contain the given values, i.e. the actual array contains some or none of the given values, or the actual array contains more values than the given ones.

Verifies that the actual array contains only the values of the given array and nothing else, in any order.

Example:

 // assertions will pass
assertThat(new long[] { 1L, 2L, 3L }).containsOnly(new Long[] { 1L, 2L, 3L });
assertThat(new long[] { 1L, 2L, 3L }).containsOnly(new Long[] { 2L, 3L, 1L });
assertThat(new long[] { 1L, 1L, 2L }).containsOnly(new Long[] { 1L, 2L });

// assertions will fail
assertThat(new long[] { 1L, 2L, 3L }).containsOnly(new Long[] { 1L, 2L, 3L, 4L });
assertThat(new long[] { 1L, 2L, 3L }).containsOnly(new Long[] { 4L, 7L });

Parameters

values:Long[]

the given values.

Returns:SELF

this assertion object.

Exceptions

NullPointerException:

if the given argument is null.

AssertionError:

• if the given argument is an empty array and the actual array is not empty.
• if the actual array is null.
• if the actual array does not contain the given values, i.e. the actual array contains some or none of the given values, or the actual array contains more values than the given ones.

Since

3.19.0

Verifies that the actual array contains the given values only once.

Examples :

 // assertion will pass
assertThat(new long[] { 1, 2, 3 }).containsOnlyOnce(1, 2);

// assertions will fail
assertThat(new long[] { 1, 2, 1 }).containsOnlyOnce(1);
assertThat(new long[] { 1, 2, 3 }).containsOnlyOnce(4);
assertThat(new long[] { 1, 2, 3, 3 }).containsOnlyOnce(0, 1, 2, 3, 4, 5);

Parameters

values:long[]

the given values.

Returns:SELF

this assertion object.

Exceptions

NullPointerException:

if the given argument is null.

AssertionError:

• if the given argument is an empty array and the actual array is not empty.
• if the actual array is null.
• if the actual group does not contain the given values, i.e. the actual group contains some or none of the given values, or the actual group contains more than once these values.

Verifies that the actual array contains the values of the given array only once.

Examples :

 // assertion will pass
assertThat(new long[] { 1, 2, 3 }).containsOnlyOnce(new Long[] { 1, 2 });

// assertions will fail
assertThat(new long[] { 1, 2, 1 }).containsOnlyOnce(new Long[] { 1 });
assertThat(new long[] { 1, 2, 3 }).containsOnlyOnce(new Long[] { 4 });
assertThat(new long[] { 1, 2, 3, 3 }).containsOnlyOnce(new Long[] { 0, 1, 2, 3, 4, 5 });

Parameters

values:Long[]

the given values.

Returns:SELF

this assertion object.

Exceptions

NullPointerException:

if the given argument is null.

AssertionError:

• if the given argument is an empty array and the actual array is not empty.
• if the actual array is null.
• if the actual group does not contain the given values, i.e. the actual group contains some or none of the given values, or the actual group contains more than once these values.

Since

3.19.0

Verifies that the actual array contains the given sequence, without any other values between them.

Example:

 // assertion will pass
assertThat(new long[] { 1, 2, 3 }).containsSequence(1, 2);

// assertion will fail
assertThat(new long[] { 1, 2, 3 }).containsSequence(1, 3);
assertThat(new long[] { 1, 2, 3 }).containsSequence(2, 1);

Parameters

sequence:long[]

the sequence of values to look for.

Returns:SELF

myself assertion object.

Exceptions

AssertionError:

• if the actual array is null.
• if the given array is null.
• if the given argument is an empty array and the actual array is not empty.
• if the actual array does not contain the given sequence.

Verifies that the actual array contains the given sequence, without any other values between them.

Example:

 // assertion will pass
assertThat(new long[] { 1, 2, 3 }).containsSequence(new Long[] { 1, 2 });

// assertion will fail
assertThat(new long[] { 1, 2, 3 }).containsSequence(new Long[] { 1, 3 });
assertThat(new long[] { 1, 2, 3 }).containsSequence(new Long[] { 2, 1 });

Parameters

sequence:Long[]

the sequence of values to look for.

Returns:SELF

myself assertion object.

Exceptions

AssertionError:

• if the actual array is null.
• if the given array is null.
• if the given argument is an empty array and the actual array is not empty.
• if the actual array does not contain the given sequence.

Since

3.19.0

Verifies that the actual array contains the given subsequence (possibly with other values between them).

Example:

 // assertion will pass
assertThat(new long[] { 1, 2, 3 }).containsSubsequence(1, 2);
assertThat(new long[] { 1, 2, 3 }).containsSubsequence(1, 3);

// assertion will fail
assertThat(new long[] { 1, 2, 3 }).containsSubsequence(2, 1);

Parameters

subsequence:long[]

the subsequence of values to look for.

Returns:SELF

myself assertion object.

Exceptions

AssertionError:

• if the actual array is null.
• if the given array is null.
• if the given argument is an empty array and the actual array is not empty.
• if the actual array does not contain the given subsequence.

Verifies that the actual array contains the given subsequence (possibly with other values between them).

Example:

 // assertion will pass
assertThat(new long[] { 1, 2, 3 }).containsSubsequence(new Long[] { 1, 2 });
assertThat(new long[] { 1, 2, 3 }).containsSubsequence(new Long[] { 1, 3 });

// assertion will fail
assertThat(new long[] { 1, 2, 3 }).containsSubsequence(new Long[] { 2, 1 });

Parameters

subsequence:Long[]

the subsequence of values to look for.

Returns:SELF

myself assertion object.

Exceptions

AssertionError:

• if the actual array is null.
• if the given array is null.
• if the given argument is an empty array and the actual array is not empty.
• if the actual array does not contain the given subsequence.

Since

3.19.0

Verifies that the actual array does not contain the given values.

Example:

 // assertion will pass
assertThat(new long[] { 1L, 2L, 3L }).doesNotContain(4L);

// assertion will fail
assertThat(new long[] { 1L, 2L, 3L }).doesNotContain(2L);

Parameters

values:long[]

the given values.

Returns:SELF

this assertion object.

Exceptions

NullPointerException:

if the given argument is null.

IllegalArgumentException:

if the given argument is an empty array.

AssertionError:

• if the actual array is null.
• if the actual array contains any of the given values.

Verifies that the actual array does not contain the values of the given array.

Example:

 // assertion will pass
assertThat(new long[] { 1L, 2L, 3L }).doesNotContain(new Long[] { 4L });

// assertion will fail
assertThat(new long[] { 1L, 2L, 3L }).doesNotContain(new Long[] { 2L });

Parameters

values:Long[]

the given values.

Returns:SELF

this assertion object.

Exceptions

NullPointerException:

if the given argument is null.

IllegalArgumentException:

if the given argument is an empty array.

AssertionError:

• if the actual array is null.
• if the actual array contains any of the given values.

Since

3.19.0

Verifies that the actual array does not contain the given value at the given index.

Example:

 // assertions will pass
assertThat(new long[] { 1L, 2L, 3L }).doesNotContain(1L, atIndex(1));
assertThat(new long[] { 1L, 2L, 3L }).doesNotContain(2L, atIndex(0));

// assertions will fail
assertThat(new long[] { 1L, 2L, 3L }).doesNotContain(1L, atIndex(0));
assertThat(new long[] { 1L, 2L, 3L }).doesNotContain(2L, atIndex(1));

Parameters

value:long

the value to look for.

index:Index

the index where the value should be stored in the actual array.

Returns:SELF

myself assertion object.

Exceptions

AssertionError:

• if the actual array is null.
• if the actual array contains the given value at the given index.

NullPointerException:

if the given Index is null.

Verifies that the actual array does not contain duplicates.

Example:

 // assertion will pass
assertThat(new long[] { 1L, 2L, 3L }).doesNotHaveDuplicates();

// assertion will fail
assertThat(new long[] { 1L, 1L, 2L, 3L }).doesNotHaveDuplicates();

Returns:SELF

this assertion object.

Exceptions

AssertionError:

• if the actual array is null.
• if the actual array contains duplicates.

Verifies that the actual array ends with the given sequence of values, without any other values between them. Similar to containsSequence(long...), but it also verifies that the last element in the sequence is also last element of the actual array.

Example:

 // assertion will pass
assertThat(new long[] { 1L, 2L, 3L }).endsWith(2L, 3L);

// assertion will fail
assertThat(new long[] { 1L, 2L, 3L }).endsWith(3L, 4L);

Parameters

sequence:long[]

the sequence of values to look for.

Returns:SELF

myself assertion object.

Exceptions

NullPointerException:

if the given argument is null.

AssertionError:

• if the actual array is null.
• if the actual array does not end with the given sequence.

Verifies that the actual array ends with the given sequence of values, without any other values between them. Similar to containsSequence(Long[]), but it also verifies that the last element in the sequence is also last element of the actual array.

Example:

 // assertion will pass
assertThat(new long[] { 1L, 2L, 3L }).endsWith(new Long[] { 2L, 3L });

// assertion will fail
assertThat(new long[] { 1L, 2L, 3L }).endsWith(new Long[] { 3L, 4L });

Parameters

sequence:Long[]

the sequence of values to look for.

Returns:SELF

myself assertion object.

Exceptions

NullPointerException:

if the given argument is null.

AssertionError:

• if the actual array is null.
• if the actual array does not end with the given sequence.

Since

3.19.0

Implements org.assertj.core.api.EnumerableAssert.hasSameSizeAs.

Doc from org.assertj.core.api.EnumerableAssert.hasSameSizeAs.

Verifies that the actual group has the same size as given Iterable.

Example:

 Iterable<String> abc = newArrayList("a", "b", "c");
Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);

// assertion will pass
assertThat(elvesRings).hasSameSizeAs(abc);

// assertions will fail
assertThat(elvesRings).hasSameSizeAs(Arrays.asList(1, 2));
assertThat(elvesRings).hasSameSizeAs(Arrays.asList(1, 2, 3, 4));

Parameters

other:Iterable<?>

the Iterable to compare size with actual group.

Returns:SELF

this assertion object.

Annotations

@Override

Implements org.assertj.core.api.EnumerableAssert.hasSize.

Doc from org.assertj.core.api.EnumerableAssert.hasSize.

Verifies that the number of values in the actual group is equal to the given one.

Example:

 // assertions will pass
assertThat(new String[] { "a", "b" }).hasSize(2);
assertThat(Arrays.asList(1, 2, 3)).hasSize(3);

// assertions will fail
assertThat(new ArrayList()).hasSize(1);
assertThat(new int[] { 1, 2, 3 }).hasSize(2);

Parameters

expected:int

the expected number of values in the actual group.

Returns:SELF

this assertion object.

Annotations

@Override

Implements org.assertj.core.api.EnumerableAssert.hasSizeBetween.

Verifies that the number of values in the actual array is between the given boundaries (inclusive).

Example:

 // assertions will pass
assertThat(new long[] { 1, 2, 3 }).hasSizeBetween(0, 4)
                                  .hasSizeBetween(3, 3);

// assertions will fail
assertThat(new long[] { 1, 2, 3 }).hasSizeBetween(4, 6);
assertThat(new long[] { 1, 2, 3 }).hasSizeBetween(0, 2);

Parameters

lowerBoundary:int

the lower boundary compared to which actual size should be greater than or equal to.

higherBoundary:int

the higher boundary compared to which actual size should be less than or equal to.

Returns:SELF

this assertion object.

Annotations

@Override

Exceptions

AssertionError:

if the number of values of the actual array is not between the boundaries.

Since

3.12.0

Implements org.assertj.core.api.EnumerableAssert.hasSizeGreaterThan.

Verifies that the number of values in the actual array is greater than the given boundary.

Example:

 // assertion will pass
assertThat(new long[] { 1, 2, 3 }).hasSizeGreaterThan(2);

// assertion will fail
assertThat(new long[] { 1, 2, 3 }).hasSizeGreaterThan(6);

Parameters

boundary:int

the given value to compare the actual size to.

Returns:SELF

this assertion object.

Annotations

@Override

Exceptions

AssertionError:

if the number of values of the actual array is not greater than the boundary.

Since

3.12.0

Implements org.assertj.core.api.EnumerableAssert.hasSizeGreaterThanOrEqualTo.

Verifies that the number of values in the actual array is greater than or equal to the given boundary.

Example:

 // assertions will pass
assertThat(new long[] { 1, 2, 3 }).hasSizeGreaterThanOrEqualTo(2)
                                  .hasSizeGreaterThanOrEqualTo(3);

// assertion will fail
assertThat(new long[] { 1, 2, 3 }).hasSizeGreaterThanOrEqualTo(4);

Parameters

boundary:int

the given value to compare the actual size to.

Returns:SELF

this assertion object.

Annotations

@Override

Exceptions

AssertionError:

if the number of values of the actual array is not greater than or equal to the boundary.

Since

3.12.0

Implements org.assertj.core.api.EnumerableAssert.hasSizeLessThan.

Verifies that the number of values in the actual array is less than the given boundary.

Example:

 // assertion will pass
assertThat(new long[] { 1, 2, 3 }).hasSizeLessThan(5);

// assertion will fail
assertThat(new long[] { 1, 2, 3 }).hasSizeLessThan(4);

Parameters

boundary:int

the given value to compare the actual size to.

Returns:SELF

this assertion object.

Annotations

@Override

Exceptions

AssertionError:

if the number of values of the actual array is not less than the boundary.

Since

3.12.0

Implements org.assertj.core.api.EnumerableAssert.hasSizeLessThanOrEqualTo.

Verifies that the number of values in the actual array is less than or equal to the given boundary.

Example:

 // assertions will pass
assertThat(new long[] { 1, 2, 3 }).hasSizeLessThanOrEqualTo(5)
                                  .hasSizeLessThanOrEqualTo(3);

// assertions will fail
assertThat(new long[] { 1, 2, 3 }).hasSizeLessThanOrEqualTo(4);

Parameters

boundary:int

the given value to compare the actual size to.

Returns:SELF

this assertion object.

Annotations

@Override

Exceptions

AssertionError:

if the number of values of the actual array is not less than or equal to the boundary.

Since

3.12.0

Implements org.assertj.core.api.EnumerableAssert.isEmpty.

Doc from org.assertj.core.api.EnumerableAssert.isEmpty.

Verifies that the actual group of values is empty.

Example:

 // assertions will pass
assertThat(new ArrayList()).isEmpty();
assertThat(new int[] { }).isEmpty();

// assertions will fail
assertThat(new String[] { "a", "b" }).isEmpty();
assertThat(Arrays.asList(1, 2, 3)).isEmpty();

Annotations

@Override

Implements org.assertj.core.api.EnumerableAssert.isNotEmpty.

Doc from org.assertj.core.api.EnumerableAssert.isNotEmpty.

Verifies that the actual group of values is not empty.

Example:

 // assertions will pass
assertThat(new String[] { "a", "b" }).isNotEmpty();
assertThat(Arrays.asList(1, 2, 3)).isNotEmpty();

// assertions will fail
assertThat(new ArrayList()).isNotEmpty();
assertThat(new int[] { }).isNotEmpty();

Returns:SELF

this assertion object.

Annotations

@Override

Implements org.assertj.core.api.EnumerableAssert.isNullOrEmpty.

Doc from org.assertj.core.api.EnumerableAssert.isNullOrEmpty.

Verifies that the actual group of values is null or empty.

Example:

 // assertions will pass
List<String> strings = new ArrayList<>();
assertThat(strings).isNullOrEmpty();
assertThat(new int[] { }).isNullOrEmpty();

// assertions will fail
assertThat(new String[] { "a", "b"}).isNullOrEmpty();
assertThat(Arrays.asList(1, 2, 3)).isNullOrEmpty();

Annotations

@Override

Implements org.assertj.core.api.ArraySortedAssert.isSorted.

Doc from org.assertj.core.api.ArraySortedAssert.isSorted.

Verifies that the actual array is sorted in ascending order according to the natural ordering of its elements.

All array elements must be primitive or implement the Comparable interface and must be mutually comparable (that is, e1.compareTo(e2) must not throw a ClassCastException for any elements e1 and e2 in the array), examples :

• a array composed of {2, 4, 6} is ok because the element type is a primitive type.
• a array composed of {"a1", "a2", "a3"} is ok because the element type (String) is Comparable
• a array composed of Rectangle {r1, r2, r3} is NOT ok because Rectangle is not Comparable
• a array composed of {True, "abc", False} is NOT ok because elements are not mutually comparable (even though each element type implements Comparable)

Returns:SELF

this assertion object.

Annotations

@Override

Implements org.assertj.core.api.ArraySortedAssert.isSortedAccordingTo.

Doc from org.assertj.core.api.ArraySortedAssert.isSortedAccordingTo.

Verifies that the actual array is sorted according to the given comparator.
Empty arrays are considered sorted whatever the comparator is.
One element arrays are considered sorted if the element is compatible with comparator, otherwise an AssertionError is thrown.

Parameters

comparator:Comparator<? super Long>

the Comparator used to compare array elements

Returns:SELF

this assertion object.

Annotations

@Override

Verifies that the actual array starts with the given sequence of values, without any other values between them. Similar to containsSequence(long...), but it also verifies that the first element in the sequence is also first element of the actual array.

Example:

 // assertion will pass
assertThat(new long[] { 1L, 2L, 3L }).startsWith(1L, 2L);

// assertion will fail
assertThat(new long[] { 1L, 2L, 3L }).startsWith(2L, 3L);

Parameters

sequence:long[]

the sequence of values to look for.

Returns:SELF

myself assertion object.

Exceptions

NullPointerException:

if the given argument is null.

AssertionError:

• if the given argument is an empty array and the actual array is not empty.
• if the actual array is null.
• if the actual array does not start with the given sequence.

Verifies that the actual array starts with the given sequence of values, without any other values between them. Similar to containsSequence(Long[]), but it also verifies that the first element in the sequence is also first element of the actual array.

Example:

 // assertion will pass
assertThat(new long[] { 1L, 2L, 3L }).startsWith(new Long[] { 1L, 2L });

// assertion will fail
assertThat(new long[] { 1L, 2L, 3L }).startsWith(new Long[] { 2L, 3L });

Parameters

sequence:Long[]

the sequence of values to look for.

Returns:SELF

myself assertion object.

Exceptions

NullPointerException:

if the given argument is null.

AssertionError:

• if the given argument is an empty array and the actual array is not empty.
• if the actual array is null.
• if the actual array does not start with the given sequence.

Since

3.19.0

Implements org.assertj.core.api.EnumerableAssert.usingDefaultElementComparator.

Doc from org.assertj.core.api.EnumerableAssert.usingDefaultElementComparator.

Revert to standard comparison for incoming assertion group element checks.

This method should be used to disable a custom comparison strategy set by calling usingElementComparator(Comparator).

Returns:SELF

this assertion object.

Annotations

@Override

@CheckReturnValue

Implements org.assertj.core.api.EnumerableAssert.usingElementComparator.

Doc from org.assertj.core.api.EnumerableAssert.usingElementComparator.

Use given custom comparator instead of relying on actual type A equals method to compare group elements for incoming assertion checks.

Custom comparator is bound to assertion instance, meaning that if a new assertion is created, it will use default comparison strategy.

 // compares invoices by payee
assertThat(invoiceList).usingComparator(invoicePayeeComparator).isEqualTo(expectedInvoiceList);

// compares invoices by date, doesNotHaveDuplicates and contains both use the given invoice date comparator
assertThat(invoiceList).usingComparator(invoiceDateComparator).doesNotHaveDuplicates().contains(may2010Invoice);

// as assertThat(invoiceList) creates a new assertion, it falls back to standard comparison strategy
// based on Invoice's equal method to compare invoiceList elements to lowestInvoice.
assertThat(invoiceList).contains(lowestInvoice);

// standard comparison : the fellowshipOfTheRing includes Gandalf but not Sauron (believe me) ...
assertThat(fellowshipOfTheRing).contains(gandalf)
                               .doesNotContain(sauron);

// ... but if we compare only races, Sauron is in fellowshipOfTheRing because he's a Maia like Gandalf.
assertThat(fellowshipOfTheRing).usingElementComparator(raceComparator)
                               .contains(sauron);

Parameters

customComparator:Comparator<? super Long>

the comparator to use for incoming assertion checks.

Returns:SELF

this assertion object.

Annotations

@Override

@CheckReturnValue