SELF
- the "self" type of this assertion class. Please read "Emulating
'self types' using Java Generics to simplify fluent API implementation" for more details.ELEMENT
- the type of elements of the "actual" value.public interface EnumerableAssert<SELF extends EnumerableAssert<SELF,ELEMENT>,ELEMENT>
Modifier and Type | Method and Description |
---|---|
SELF |
hasSameSizeAs(Iterable<?> other)
Verifies that the actual group has the same size as given
Iterable . |
SELF |
hasSameSizeAs(Object array)
Verifies that the actual group has the same size as given array.
|
SELF |
hasSize(int expected)
Verifies that the number of values in the actual group is equal to the given one.
|
SELF |
hasSizeBetween(int lowerBoundary,
int higherBoundary)
Verifies that the number of values in the actual group is between the given boundaries (inclusive).
|
SELF |
hasSizeGreaterThan(int boundary)
Verifies that the number of values in the actual group is greater than the given boundary.
|
SELF |
hasSizeGreaterThanOrEqualTo(int boundary)
Verifies that the number of values in the actual group is greater than or equal to the given boundary.
|
SELF |
hasSizeLessThan(int boundary)
Verifies that the number of values in the actual group is less than the given boundary.
|
SELF |
hasSizeLessThanOrEqualTo(int boundary)
Verifies that the number of values in the actual group is less than or equal to the given boundary.
|
void |
isEmpty()
Verifies that the actual group of values is empty.
|
SELF |
isNotEmpty()
Verifies that the actual group of values is not empty.
|
void |
isNullOrEmpty()
Verifies that the actual group of values is
null or empty. |
SELF |
usingDefaultElementComparator()
Revert to standard comparison for incoming assertion group element checks.
|
SELF |
usingElementComparator(Comparator<? super ELEMENT> customComparator)
Use given custom comparator instead of relying on actual type A
equals method to compare group
elements for incoming assertion checks. |
void isNullOrEmpty()
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();
AssertionError
- if the actual group of values is not null
or not empty.void isEmpty()
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();
AssertionError
- if the actual group of values is not empty.SELF isNotEmpty()
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();
this
assertion object.AssertionError
- if the actual group of values is empty.SELF hasSize(int expected)
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);
expected
- the expected number of values in the actual group.this
assertion object.AssertionError
- if the number of values of the actual group is not equal to the given one.SELF hasSizeGreaterThan(int boundary)
Example:
// assertions will pass
assertThat(new String[] { "a", "b" }).hasSizeGreaterThan(1);
assertThat(Arrays.asList(1, 2, 3)).hasSizeGreaterThan(2);
// assertions will fail
assertThat(Arrays.asList(1, 2, 3)).hasSizeGreaterThan(3);
assertThat(new int[] { 1, 2, 3 }).hasSizeGreaterThan(6);
boundary
- the given value to compare the actual size to.this
assertion object.AssertionError
- if the number of values of the actual group is not greater than the boundary.SELF hasSizeGreaterThanOrEqualTo(int boundary)
Example:
// assertions will pass
assertThat(Arrays.asList(1, 2, 3)).hasSizeGreaterThanOrEqualTo(3);
assertThat(Arrays.asList(1, 2)).hasSizeGreaterThanOrEqualTo(1);
// assertions will fail
assertThat(Arrays.asList(1, 2)).hasSizeGreaterThanOrEqualTo(3);
assertThat(new int[] { 1, 2, 3 }).hasSizeGreaterThanOrEqualTo(4);
boundary
- the given value to compare the actual size to.this
assertion object.AssertionError
- if the number of values of the actual group is not greater than or equal to the boundary.SELF hasSizeLessThan(int boundary)
Example:
// assertions will pass
assertThat(new String[] { "a", "b" }).hasSizeLessThan(5);
assertThat(Arrays.asList(1, 2, 3)).hasSizeLessThan(4);
// assertions will fail
assertThat(Arrays.asList(1, 2, 3)).hasSizeLessThan(3);
assertThat(new int[] { 1, 2, 3 }).hasSizeLessThan(2);
boundary
- the given value to compare the actual size to.this
assertion object.AssertionError
- if the number of values of the actual group is not less than the boundary.SELF hasSizeLessThanOrEqualTo(int boundary)
Example:
// assertions will pass
assertThat(new String[] { "a", "b" }).hasSizeLessThanOrEqualTo(3);
assertThat(Arrays.asList(1, 2, 3)).hasSizeLessThanOrEqualTo(5)
.hasSizeLessThanOrEqualTo(3);
// assertions will fail
assertThat(Arrays.asList(1, 2, 3)).hasSizeLessThanOrEqualTo(2);
assertThat(new int[] { 1, 2, 3 }).hasSizeLessThanOrEqualTo(1);
boundary
- the given value to compare the actual size to.this
assertion object.AssertionError
- if the number of values of the actual group is not less than or equal to the boundary.SELF hasSizeBetween(int lowerBoundary, int higherBoundary)
Example:
// assertions will pass
assertThat(new String[] { "a", "b" }).hasSizeBetween(0, 4);
assertThat(Arrays.asList(1, 2, 3)).hasSizeBetween(2, 3)
.hasSizeBetween(3, 4)
.hasSizeBetween(3, 3);
// assertions will fail
assertThat(new ArrayList()).hasSizeBetween(1, 3);
assertThat(new int[] { 1, 2, 3 }).hasSizeBetween(4, 6);
assertThat(new int[] { 1, 2, 3, 4 }).hasSizeBetween(0, 2);
lowerBoundary
- the lower boundary compared to which actual size should be greater than or equal to.higherBoundary
- the higher boundary compared to which actual size should be less than or equal to.this
assertion object.AssertionError
- if the number of values of the actual group is not between the boundaries.SELF hasSameSizeAs(Iterable<?> other)
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));
other
- the Iterable
to compare size with actual group.this
assertion object.AssertionError
- if the actual group is null
.AssertionError
- if the other Iterable
is null
.AssertionError
- if actual group and given Iterable
don't have the same size.SELF hasSameSizeAs(Object array)
Parameter is declared as Object to accept both Object[] and primitive arrays (e.g. int[]).
Example: int[] oneTwoThree = {1, 2, 3};
Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);
// assertion will pass
assertThat(elvesRings).hasSameSizeAs(oneTwoThree);
// assertions will fail
assertThat(elvesRings).hasSameSizeAs(new int[] { 1, 2});
assertThat(elvesRings).hasSameSizeAs(new int[] { 1, 2, 3, 4});
array
- the array to compare size with actual group.this
assertion object.AssertionError
- if the actual group is null
.AssertionError
- if the array parameter is null
or is not a true array.AssertionError
- if actual group and given array don't have the same size.SELF usingElementComparator(Comparator<? super ELEMENT> customComparator)
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.
Examples : // 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);
customComparator
- the comparator to use for incoming assertion checks.this
assertion object.NullPointerException
- if the given comparator is null
.SELF usingDefaultElementComparator()
This method should be used to disable a custom comparison strategy set by calling
usingElementComparator(Comparator)
.
this
assertion object.Copyright © 2014–2019 AssertJ. All rights reserved.