Class AssertionsForInterfaceTypes
- java.lang.Object
-
- org.assertj.core.api.AssertionsForClassTypes
-
- org.assertj.core.api.AssertionsForInterfaceTypes
-
public class AssertionsForInterfaceTypes extends AssertionsForClassTypes
Entry point for assertion methods for different data types. Each method in this class is a static factory for the type-specific assertion objects. The purpose of this class is to make test code more readable.For example:
Java 8 is picky when choosing the rightint removed = employees.removeFired();
assertThat
(removed).isZero
(); List<Employee> newEmployees = employees.hired(TODAY);assertThat
(newEmployees).hasSize
(6);assertThat
method if the object under test is generic and bounded, for example if foo is instance of T that extends Exception, java 8 will complain that it can't resolve the properassertThat
method (normallyassertThat(Throwable)
as foo might implement an interface like List, if that occurredassertThat(List)
would also be a possible choice - thus confusing java 8.This why
Assertions
have been split inAssertionsForClassTypes
andAssertionsForInterfaceTypes
(see http://stackoverflow.com/questions/29499847/ambiguous-method-in-java-8-why).- Author:
- Alex Ruiz, Yvonne Wang, David DIDIER, Ted Young, Joel Costigliola, Matthieu Baechler, Mikhail Mazursky, Nicolas François, Julien Meddah, William Bakker, William Delanoue, Turbo87, dorzey
-
-
Constructor Summary
Constructors Modifier Constructor Description protected
AssertionsForInterfaceTypes()
Creates a new
.Assertions
-
Method Summary
All Methods Static Methods Concrete Methods Modifier and Type Method Description static <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
ClassBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT>assertThat(ACTUAL actual, Class<ELEMENT_ASSERT> assertClass)
static AbstractCharSequenceAssert<?,? extends CharSequence>
assertThat(CharSequence actual)
Creates a new instance of
.CharSequenceAssert
static <ELEMENT> IterableAssert<ELEMENT>
assertThat(Iterable<? extends ELEMENT> actual)
Creates a new instance of
.IterableAssert
static <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
FactoryBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT>assertThat(Iterable<? extends ELEMENT> actual, AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
Creates a new instance of
.IterableAssert
static AbstractPathAssert<?>
assertThat(Path actual)
Creates a new instance ofPathAssert
static <RESULT> CompletableFutureAssert<RESULT>
assertThat(CompletionStage<RESULT> actual)
Create assertion forCompletionStage
by converting it to aCompletableFuture
and returning aCompletableFutureAssert
.static DoublePredicateAssert
assertThat(DoublePredicate actual)
Create assertion forDoublePredicate
.static IntPredicateAssert
assertThat(IntPredicate actual)
Create assertion forIntPredicate
.static LongPredicateAssert
assertThat(LongPredicate actual)
Create assertion forLongPredicate
.static <T> PredicateAssert<T>
assertThat(Predicate<T> actual)
Create assertion forPredicate
.static <ELEMENT> IteratorAssert<ELEMENT>
assertThat(Iterator<? extends ELEMENT> actual)
Creates a new instance of
.IteratorAssert
static <ELEMENT> ListAssert<ELEMENT>
assertThat(List<? extends ELEMENT> actual)
Creates a new instance of
.ListAssert
static <ELEMENT,ACTUAL extends List<? extends ELEMENT>,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
ClassBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT>assertThat(List<? extends ELEMENT> actual, Class<ELEMENT_ASSERT> assertClass)
static <ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
FactoryBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT>assertThat(List<? extends ELEMENT> actual, AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
static <K,V>
MapAssert<K,V>assertThat(Map<K,V> actual)
Creates a new instance of
.MapAssert
static <ELEMENT> SpliteratorAssert<ELEMENT>
assertThat(Spliterator<ELEMENT> actual)
Create assertion forSpliteratorAssert
.static ListAssert<Double>
assertThat(DoubleStream actual)
Creates a new instance of
from the givenListAssert
DoubleStream
.static ListAssert<Integer>
assertThat(IntStream actual)
Creates a new instance of
from the givenListAssert
IntStream
.static ListAssert<Long>
assertThat(LongStream actual)
Creates a new instance of
from the givenListAssert
LongStream
.static <ELEMENT> ListAssert<ELEMENT>
assertThat(Stream<? extends ELEMENT> actual)
Creates a new instance of
from the givenListAssert
Stream
.static <T> T
assertThat(AssertProvider<T> component)
Delegates the creation of theAssert
to theAssertProvider.assertThat()
of the given component.static <T extends Comparable<? super T>>
AbstractComparableAssert<?,T>assertThat(T actual)
Creates a new instance of
with standard comparison semantics.GenericComparableAssert
-
Methods inherited from class org.assertj.core.api.AssertionsForClassTypes
allOf, allOf, anyOf, anyOf, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThatCode, assertThatExceptionOfType, assertThatThrownBy, assertThatThrownBy, atIndex, catchThrowable, catchThrowableOfType, contentOf, contentOf, contentOf, contentOf, contentOf, contentOf, doesNotHave, entry, extractProperty, extractProperty, fail, fail, failBecauseExceptionWasNotThrown, filter, filter, in, linesOf, linesOf, linesOf, linesOf, linesOf, linesOf, not, not, notIn, offset, offset, registerCustomDateFormat, registerCustomDateFormat, setAllowComparingPrivateFields, setAllowExtractingPrivateFields, setLenientDateParsing, setMaxLengthForSingleLineDescription, setRemoveAssertJRelatedElementsFromStackTrace, shouldHaveThrown, tuple, useDefaultDateFormatsOnly, within, within, within, within, within, within, within, withinPercentage, withinPercentage, withinPercentage
-
-
-
-
Constructor Detail
-
AssertionsForInterfaceTypes
protected AssertionsForInterfaceTypes()
Creates a new
.Assertions
-
-
Method Detail
-
assertThat
public static <T> T assertThat(AssertProvider<T> component)
Delegates the creation of theAssert
to theAssertProvider.assertThat()
of the given component.Read the comments on
AssertProvider
for an example of its usage.- Type Parameters:
T
- the AssertProvider wrapped type.- Parameters:
component
- the component that creates its own assert- Returns:
- the associated
Assert
of the given component
-
assertThat
public static AbstractCharSequenceAssert<?,? extends CharSequence> assertThat(CharSequence actual)
Creates a new instance of
.CharSequenceAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static <ELEMENT> IterableAssert<ELEMENT> assertThat(Iterable<? extends ELEMENT> actual)
Creates a new instance of
.IterableAssert
- Type Parameters:
ELEMENT
- the type of elements.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static <ELEMENT> IteratorAssert<ELEMENT> assertThat(Iterator<? extends ELEMENT> actual)
Creates a new instance of
.IteratorAssert
- Type Parameters:
ELEMENT
- the type of elements.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static <ELEMENT> ListAssert<ELEMENT> assertThat(List<? extends ELEMENT> actual)
Creates a new instance of
.ListAssert
- Type Parameters:
ELEMENT
- the type of elements.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static <ELEMENT> ListAssert<ELEMENT> assertThat(Stream<? extends ELEMENT> actual)
Creates a new instance of
from the givenListAssert
Stream
.Be aware that the
Stream
under test will be converted to aList
when an assertions require to inspect its content. Once this is done theStream
can't reused as it would have been consumed.Calling multiple methods on the returned
ListAssert
is safe as it only interacts with theList
built from theStream
.Examples:
// you can chain multiple assertions on the Stream as it is converted to a List assertThat(Stream.of(1, 2, 3)).contains(1) .doesNotContain(42);
The following assertion fails as the Stream under test is converted to a List before being compared to the expected Stream:
// FAIL: the Stream under test is converted to a List and compared to a Stream but a List is not a Stream. assertThat(Stream.of(1, 2, 3)).isEqualTo(Stream.of(1, 2, 3));
These assertions succeed as
isEqualTo
andisSameAs
checks references which does not require to convert the Stream to a List.// The following assertions succeed as it only performs reference checking which does not require to convert the Stream to a List Stream<Integer> stream = Stream.of(1, 2, 3); assertThat(stream).isEqualTo(stream) .isSameAs(stream);
- Type Parameters:
ELEMENT
- the type of elements.- Parameters:
actual
- the actualStream
value.- Returns:
- the created assertion object.
-
assertThat
public static ListAssert<Double> assertThat(DoubleStream actual)
Creates a new instance of
from the givenListAssert
DoubleStream
.Be aware that the
DoubleStream
under test will be converted to aList
when an assertions require to inspect its content. Once this is done theDoubleStream
can't reused as it would have been consumed.Calling multiple methods on the returned
ListAssert
is safe as it only interacts with theList
built from theDoubleStream
.Examples:
// you can chain multiple assertions on the DoubleStream as it is converted to a List assertThat(DoubleStream.of(1.0, 2.0, 3.0)).contains(1.0) .doesNotContain(42.0);
The following assertion fails as the DoubleStream under test is converted to a List before being compared to the expected DoubleStream:
// FAIL: the DoubleStream under test is converted to a List and compared to a DoubleStream but a List is not a DoubleStream. assertThat(DoubleStream.of(1.0, 2.0, 3.0)).isEqualTo(DoubleStream.of(1.0, 2.0, 3.0));
These assertions succeed as
isEqualTo
andisSameAs
checks references which does not require to convert the DoubleStream to a List.// The following assertions succeed as it only performs reference checking which does not require to convert the DoubleStream to a List DoubleStream stream = DoubleStream.of(1.0, 2.0, 3.0); assertThat(stream).isEqualTo(stream) .isSameAs(stream);
- Parameters:
actual
- the actualDoubleStream
value.- Returns:
- the created assertion object.
-
assertThat
public static ListAssert<Long> assertThat(LongStream actual)
Creates a new instance of
from the givenListAssert
LongStream
.Be aware that the
LongStream
under test will be converted to aList
when an assertions require to inspect its content. Once this is done theLongStream
can't reused as it would have been consumed.Calling multiple methods on the returned
ListAssert
is safe as it only interacts with theList
built from theLongStream
.Examples:
// you can chain multiple assertions on the LongStream as it is converted to a List assertThat(LongStream.of(1, 2, 3)).contains(1) .doesNotContain(42);
The following assertion fails as the LongStream under test is converted to a List before being compared to the expected LongStream:
// FAIL: the LongStream under test is converted to a List and compared to a LongStream but a List is not a LongStream. assertThat(LongStream.of(1, 2, 3)).isEqualTo(LongStream.of(1, 2, 3));
These assertions succeed as
isEqualTo
andisSameAs
checks references which does not require to convert the LongStream to a List.// The following assertions succeed as it only performs reference checking which does not require to convert the LongStream to a List LongStream stream = LongStream.of(1, 2, 3); assertThat(stream).isEqualTo(stream) .isSameAs(stream);
- Parameters:
actual
- the actualLongStream
value.- Returns:
- the created assertion object.
-
assertThat
public static ListAssert<Integer> assertThat(IntStream actual)
Creates a new instance of
from the givenListAssert
IntStream
.Be aware that the
IntStream
under test will be converted to aList
when an assertions require to inspect its content. Once this is done theIntStream
can't reused as it would have been consumed.Calling multiple methods on the returned
ListAssert
is safe as it only interacts with theList
built from theIntStream
.Examples:
// you can chain multiple assertions on the IntStream as it is converted to a List assertThat(IntStream.of(1, 2, 3)).contains(1) .doesNotContain(42);
The following assertion fails as the IntStream under test is converted to a List before being compared to the expected IntStream:
// FAIL: the IntStream under test is converted to a List and compared to a IntStream but a List is not a IntStream. assertThat(IntStream.of(1, 2, 3)).isEqualTo(IntStream.of(1, 2, 3));
These assertions succeed as
isEqualTo
andisSameAs
checks references which does not require to convert the IntStream to a List.// The following assertions succeed as it only performs reference checking which does not require to convert the IntStream to a List IntStream stream = IntStream.of(1, 2, 3); assertThat(stream).isEqualTo(stream) .isSameAs(stream);
- Parameters:
actual
- the actualIntStream
value.- Returns:
- the created assertion object.
-
assertThat
public static <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> FactoryBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(Iterable<? extends ELEMENT> actual, AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
Creates a new instance of
.IterableAssert
- Type Parameters:
ACTUAL
- The actual typeELEMENT
- The actual elements typeELEMENT_ASSERT
- The actual elements AbstractAssert type- Parameters:
actual
- the actual value.assertFactory
- the factory used to create the elements assert instance.- Returns:
- the created assertion object.
-
assertThat
public static <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> ClassBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(ACTUAL actual, Class<ELEMENT_ASSERT> assertClass)
-
assertThat
public static <ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> FactoryBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(List<? extends ELEMENT> actual, AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
-
assertThat
public static <ELEMENT,ACTUAL extends List<? extends ELEMENT>,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> ClassBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(List<? extends ELEMENT> actual, Class<ELEMENT_ASSERT> assertClass)
-
assertThat
public static AbstractPathAssert<?> assertThat(Path actual)
Creates a new instance ofPathAssert
- Parameters:
actual
- the path to test- Returns:
- the created assertion object
-
assertThat
public static <K,V> MapAssert<K,V> assertThat(Map<K,V> actual)
Creates a new instance of
.MapAssert
Returned type is
MapAssert
as it overrides method to annotate them withSafeVarargs
avoiding annoying warnings.- Type Parameters:
K
- the type of keys in the map.V
- the type of values in the map.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static <T extends Comparable<? super T>> AbstractComparableAssert<?,T> assertThat(T actual)
Creates a new instance of
with standard comparison semantics.GenericComparableAssert
- Type Parameters:
T
- the type of actual.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static <T extends AssertDelegateTarget> T assertThat(T assertion)
Returns the given assertion. This method improves code readability by surrounding the given assertion withassertThat
.Consider for example the following MyButton and MyButtonAssert classes:
As MyButtonAssert implements AssertDelegateTarget, you can usepublic class MyButton extends JButton { private boolean blinking; public boolean isBlinking() { return this.blinking; } public void setBlinking(boolean blink) { this.blinking = blink; } } private static class MyButtonAssert implements AssertDelegateTarget { private MyButton button; MyButtonAssert(MyButton button) { this.button = button; } void isBlinking() { // standard assertion from core Assertions.assertThat assertThat(button.isBlinking()).isTrue(); } void isNotBlinking() { // standard assertion from core Assertions.assertThat assertThat(button.isBlinking()).isFalse(); } }
assertThat(buttonAssert).isBlinking();
instead ofbuttonAssert.isBlinking();
to have easier to read assertions:@Test public void AssertDelegateTarget_example() { MyButton button = new MyButton(); MyButtonAssert buttonAssert = new MyButtonAssert(button); // you can encapsulate MyButtonAssert assertions methods within assertThat assertThat(buttonAssert).isNotBlinking(); // same as : buttonAssert.isNotBlinking(); button.setBlinking(true); assertThat(buttonAssert).isBlinking(); // same as : buttonAssert.isBlinking(); }
- Type Parameters:
T
- the generic type of the user-defined assert.- Parameters:
assertion
- the assertion to return.- Returns:
- the given assertion.
-
assertThat
public static <T> PredicateAssert<T> assertThat(Predicate<T> actual)
Create assertion forPredicate
.- Type Parameters:
T
- the type of the value contained in thePredicate
.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
- Since:
- 3.5.0
-
assertThat
public static IntPredicateAssert assertThat(IntPredicate actual)
Create assertion forIntPredicate
.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
- Since:
- 3.5.0
-
assertThat
public static LongPredicateAssert assertThat(LongPredicate actual)
Create assertion forLongPredicate
.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
- Since:
- 3.5.0
-
assertThat
public static DoublePredicateAssert assertThat(DoublePredicate actual)
Create assertion forDoublePredicate
.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
- Since:
- 3.5.0
-
assertThat
public static <RESULT> CompletableFutureAssert<RESULT> assertThat(CompletionStage<RESULT> actual)
Create assertion forCompletionStage
by converting it to aCompletableFuture
and returning aCompletableFutureAssert
.If the given
CompletionStage
is null, theCompletableFuture
in the returnedCompletableFutureAssert
will also be null.- Type Parameters:
RESULT
- the type of the value contained in theCompletionStage
.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static <ELEMENT> SpliteratorAssert<ELEMENT> assertThat(Spliterator<ELEMENT> actual)
Create assertion forSpliteratorAssert
.- Type Parameters:
ELEMENT
- the type of elements- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
-