S
- the "self" type of this assertion class. Please read "Emulating
'self types' using Java Generics to simplify fluent API implementation" for more details.A
- the type of the "actual" value.public interface Assert<S extends Assert<S,A>,A> extends Descriptable<S>, ExtensionPoints<S,A>
Modifier and Type | Method and Description |
---|---|
AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>> |
asList()
Verifies that the actual value is an instance of List,
and returns a list assertion, to allow chaining of list-specific
assertions from this call.
|
AbstractCharSequenceAssert<?,String> |
asString()
Verifies that the actual value is an instance of String,
and returns a String assertion, to allow chaining of String-specific
assertions from this call.
|
S |
doesNotHaveSameClassAs(Object other)
Verifies that the actual value does not have the same class as the given object.
|
boolean |
equals(Object obj)
Deprecated.
Throws
if called. It is easy to accidentally call
instead of . |
S |
hasSameClassAs(Object other)
Verifies that the actual value has the same class as the given object.
|
S |
hasToString(String expectedToString)
Verifies that actual
actual.toString() is equal to the given String . |
S |
isEqualTo(Object expected)
Verifies that the actual value is equal to the given one.
|
S |
isExactlyInstanceOf(Class<?> type)
Verifies that the actual value is exactly an instance of the given type.
|
S |
isIn(Iterable<?> values)
Verifies that the actual value is present in the given values.
|
S |
isIn(Object... values)
Verifies that the actual value is present in the given array of values.
|
S |
isInstanceOf(Class<?> type)
Verifies that the actual value is an instance of the given type.
|
S |
isInstanceOfAny(Class<?>... types)
Verifies that the actual value is an instance of any of the given types.
|
S |
isNotEqualTo(Object other)
Verifies that the actual value is not equal to the given one.
|
S |
isNotExactlyInstanceOf(Class<?> type)
Verifies that the actual value is not exactly an instance of given type.
|
S |
isNotIn(Iterable<?> values)
Verifies that the actual value is not present in the given values.
|
S |
isNotIn(Object... values)
Verifies that the actual value is not present in the given array of values.
|
S |
isNotInstanceOf(Class<?> type)
Verifies that the actual value is not an instance of the given type.
|
S |
isNotInstanceOfAny(Class<?>... types)
Verifies that the actual value is not an instance of any of the given types.
|
S |
isNotNull()
Verifies that the actual value is not
null . |
S |
isNotOfAnyClassIn(Class<?>... types)
Verifies that the actual value type is not in given types.
|
S |
isNotSameAs(Object other)
Verifies that the actual value is not the same as the given one, ie using == comparison.
|
void |
isNull()
Verifies that the actual value is
null . |
S |
isOfAnyClassIn(Class<?>... types)
Verifies that the actual value type is in given types.
|
S |
isSameAs(Object expected)
Verifies that the actual value is the same as the given one, ie using == comparison.
|
S |
usingComparator(Comparator<? super A> customComparator)
Use given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
|
S |
usingDefaultComparator()
Revert to standard comparison for incoming assertion checks.
|
S |
withRepresentation(Representation representation)
Use the given
Representation to describe/represent values in AssertJ error messages. |
S |
withThreadDumpOnError()
In case of assertion error, the thread dump will be printed on
System.err . |
as, as, describedAs, describedAs
doesNotHave, has, is, isNot
S isEqualTo(Object expected)
Example:
// assertions will pass
assertThat("abc").isEqualTo("abc");
assertThat(new HashMap<String, Integer>()).isEqualTo(new HashMap<String, Integer>());
// assertions will fail
assertThat("abc").isEqualTo("123");
assertThat(new ArrayList<String>()).isEqualTo(1);
expected
- the given value to compare the actual value to.this
assertion object.AssertionError
- if the actual value is not equal to the given one.S isNotEqualTo(Object other)
Example:
// assertions will pass
assertThat("abc").isNotEqualTo("123");
assertThat(new ArrayList<String>()).isNotEqualTo(1);
// assertions will fail
assertThat("abc").isNotEqualTo("abc");
assertThat(new HashMap<String, Integer>()).isNotEqualTo(new HashMap<String, Integer>());
other
- the given value to compare the actual value to.this
assertion object.AssertionError
- if the actual value is equal to the given one.void isNull()
null
.
Example:
String value = null;
// assertion will pass
assertThat(value).isNull();
// assertions will fail
assertThat("abc").isNull();
assertThat(new HashMap<String, Integer>()).isNull();
AssertionError
- if the actual value is not null
.S isNotNull()
null
.
Example:
// assertion will pass
assertThat("abc").isNotNull();
assertThat(new HashMap<String, Integer>()).isNotNull();
// assertion will fail
String value = null;
assertThat(value).isNotNull();
this
assertion object.AssertionError
- if the actual value is null
.S isSameAs(Object expected)
Example:
// Name is a class with first and last fields, two Names are equals if both first and last are equals.
Name tyrion = new Name("Tyrion", "Lannister");
Name alias = tyrion;
Name clone = new Name("Tyrion", "Lannister");
// assertions succeed:
assertThat(tyrion).isSameAs(alias)
.isEqualTo(clone);
// assertion fails:
assertThat(tyrion).isSameAs(clone);
expected
- the given value to compare the actual value to.this
assertion object.AssertionError
- if the actual value is not the same as the given one.S isNotSameAs(Object other)
Example:
// Name is a class with first and last fields, two Names are equals if both first and last are equals.
Name tyrion = new Name("Tyrion", "Lannister");
Name alias = tyrion;
Name clone = new Name("Tyrion", "Lannister");
// assertions succeed:
assertThat(clone).isNotSameAs(tyrion)
.isEqualTo(tyrion);
// assertion fails:
assertThat(alias).isNotSameAs(tyrion);
other
- the given value to compare the actual value to.this
assertion object.AssertionError
- if the actual value is the same as the given one.S isIn(Object... values)
Example:
Ring[] elvesRings = new Ring[] { vilya, nenya, narya };
// assertion will pass:
assertThat(nenya).isIn(elvesRings);
// assertion will fail:
assertThat(oneRing).isIn(elvesRings);
values
- the given array to search the actual value in.this
assertion object.NullPointerException
- if the given array is null
.IllegalArgumentException
- if the given array is empty.AssertionError
- if the actual value is not present in the given array.S isNotIn(Object... values)
Example:
Ring[] elvesRings = new Ring[] { vilya, nenya, narya };
// assertion will pass:
assertThat(oneRing).isNotIn(elvesRings);
// assertion will fail:
assertThat(nenya).isNotIn(elvesRings);
values
- the given array to search the actual value in.this
assertion object.NullPointerException
- if the given array is null
.IllegalArgumentException
- if the given array is empty.AssertionError
- if the actual value is present in the given array.S isIn(Iterable<?> values)
Example:
Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);
// assertion will pass:
assertThat(nenya).isIn(elvesRings);
// assertion will fail:
assertThat(oneRing).isIn(elvesRings);
values
- the given iterable to search the actual value in.this
assertion object.NullPointerException
- if the given collection is null
.IllegalArgumentException
- if the given collection is empty.AssertionError
- if the actual value is not present in the given collection.S isNotIn(Iterable<?> values)
Example:
Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);
// assertion will pass:
assertThat(oneRing).isNotIn(elvesRings);
// assertion will fail:
assertThat(nenya).isNotIn(elvesRings);
values
- the given iterable to search the actual value in.this
assertion object.NullPointerException
- if the given collection is null
.IllegalArgumentException
- if the given collection is empty.AssertionError
- if the actual value is present in the given collection.S usingComparator(Comparator<? super A> customComparator)
Custom comparator is bound to assertion instance, meaning that if a new assertion is created, it will use default comparison strategy. Examples :
// frodo and sam are instances of Character with Hobbit race (obviously :).
// raceComparator implements Comparator<Character>
assertThat(frodo).usingComparator(raceComparator).isEqualTo(sam);
customComparator
- the comparator to use for incoming assertion checks.this
assertion object.NullPointerException
- if the given comparator is null
.S usingDefaultComparator()
This method should be used to disable a custom comparison strategy set by calling
usingComparator(Comparator)
.
this
assertion object.S isInstanceOf(Class<?> type)
Example:
// assertions will pass
assertThat("abc").isInstanceOf(String.class);
assertThat(new HashMap<String, Integer>()).isInstanceOf(HashMap.class);
assertThat(new HashMap<String, Integer>()).isInstanceOf(Map.class);
// assertions will fail
assertThat(1).isInstanceOf(String.class);
assertThat(new ArrayList<String>()).isInstanceOf(LinkedList.class);
type
- the type to check the actual value against.NullPointerException
- if the given type is null
.AssertionError
- if the actual value is null
.AssertionError
- if the actual value is not an instance of the given type.S isInstanceOfAny(Class<?>... types)
Example:
// assertions will pass
assertThat("abc").isInstanceOfAny(String.class, Integer.class);
assertThat(new ArrayList<String>()).isInstanceOfAny(LinkedList.class, ArrayList.class);
assertThat(new HashMap<String, Integer>()).isInstanceOfAny(TreeMap.class, Map.class);
// assertions will fail
assertThat(1).isInstanceOfAny(Double.class, Float.class);
assertThat(new ArrayList<String>()).isInstanceOfAny(LinkedList.class, Vector.class);
types
- the types to check the actual value against.AssertionError
- if the actual value is null
.AssertionError
- if the actual value is not an instance of any of the given types.NullPointerException
- if the given array of types is null
.NullPointerException
- if the given array of types contains null
s.S isNotInstanceOf(Class<?> type)
Example:
// assertions will pass
assertThat(1).isNotInstanceOf(Double.class);
assertThat(new ArrayList<String>()).isNotInstanceOf(LinkedList.class);
// assertions will fail
assertThat("abc").isNotInstanceOf(String.class);
assertThat(new HashMap<String, Integer>()).isNotInstanceOf(HashMap.class);
assertThat(new HashMap<String, Integer>()).isNotInstanceOf(Map.class);
type
- the type to check the actual value against.NullPointerException
- if the given type is null
.AssertionError
- if the actual value is null
.AssertionError
- if the actual value is an instance of the given type.S isNotInstanceOfAny(Class<?>... types)
Example:
// assertions will pass
assertThat(1).isNotInstanceOfAny(Double.class, Float.class);
assertThat(new ArrayList<String>()).isNotInstanceOfAny(LinkedList.class, Vector.class);
// assertions will fail
assertThat(1).isNotInstanceOfAny(Double.class, Integer.class);
assertThat(new ArrayList<String>()).isNotInstanceOfAny(LinkedList.class, ArrayList.class);
assertThat(new HashMap<String, Integer>()).isNotInstanceOfAny(TreeMap.class, Map.class);
types
- the types to check the actual value against.AssertionError
- if the actual value is null
.AssertionError
- if the actual value is an instance of any of the given types.NullPointerException
- if the given array of types is null
.NullPointerException
- if the given array of types contains null
s.S hasSameClassAs(Object other)
Example:
// assertions will pass
assertThat(1).hasSameClassAs(2);
assertThat("abc").hasSameClassAs("123");
assertThat(new ArrayList<String>()).hasSameClassAs(new ArrayList<Integer>());
// assertions will fail
assertThat(1).hasSameClassAs("abc");
assertThat(new ArrayList<String>()).hasSameClassAs(new LinkedList<String>());
other
- the object to check type against.AssertionError
- if the actual has not the same type has the given object.NullPointerException
- if the actual value is null.NullPointerException
- if the given object is null.S hasToString(String expectedToString)
actual.toString()
is equal to the given String
.
Example :
CartoonCaracter homer = new CartoonCaracter("Homer");
// Instead of writing ...
assertThat(homer.toString()).isEqualTo("Homer");
// ... you can simply write:
assertThat(homer).hasToString("Homer");
expectedToString
- the expected String description of actual.AssertionError
- if actual.toString()
result is not to the given String
.AssertionError
- if actual is null
.S doesNotHaveSameClassAs(Object other)
Example:
// assertions will pass
assertThat(1).doesNotHaveSameClassAs("abc");
assertThat(new ArrayList<String>()).doesNotHaveSameClassAs(new LinkedList<String>());
// assertions will fail
assertThat(1).doesNotHaveSameClassAs(2);
assertThat("abc").doesNotHaveSameClassAs("123");
assertThat(new ArrayList<String>()).doesNotHaveSameClassAs(new ArrayList<Integer>());
other
- the object to check type against.AssertionError
- if the actual has the same type has the given object.NullPointerException
- if the actual value is null.NullPointerException
- if the given object is null.S isExactlyInstanceOf(Class<?> type)
Example:
// assertions will pass
assertThat("abc").isExactlyInstanceOf(String.class);
assertThat(new ArrayList<String>()).isExactlyInstanceOf(ArrayList.class);
assertThat(new HashMap<String, Integer>()).isExactlyInstanceOf(HashMap.class);
// assertions will fail
assertThat(1).isExactlyInstanceOf(String.class);
assertThat(new ArrayList<String>()).isExactlyInstanceOf(List.class);
assertThat(new HashMap<String, Integer>()).isExactlyInstanceOf(Map.class);
type
- the type to check the actual value against.AssertionError
- if the actual is not exactly an instance of given type.NullPointerException
- if the actual value is null.NullPointerException
- if the given object is null.S isNotExactlyInstanceOf(Class<?> type)
Example:
// assertions will pass
assertThat(1).isNotExactlyInstanceOf(String.class);
assertThat(new ArrayList<String>()).isNotExactlyInstanceOf(List.class);
assertThat(new HashMap<String, Integer>()).isNotExactlyInstanceOf(Map.class);
// assertions will fail
assertThat("abc").isNotExactlyInstanceOf(String.class);
assertThat(new ArrayList<String>()).isNotExactlyInstanceOf(ArrayList.class);
assertThat(new HashMap<String, Integer>()).isNotExactlyInstanceOf(HashMap.class);
type
- the type to check the actual value against.AssertionError
- if the actual is exactly an instance of given type.NullPointerException
- if the actual value is null.NullPointerException
- if the given object is null.S isOfAnyClassIn(Class<?>... types)
Example:
// assertions will pass
assertThat(new HashMap<String, Integer>()).isOfAnyClassIn(HashMap.class, TreeMap.class);
assertThat(new ArrayList<String>()).isOfAnyClassIn(ArrayList.class, LinkedList.class);
// assertions will fail
assertThat(new HashMap<String, Integer>()).isOfAnyClassIn(TreeMap.class, Map.class);
assertThat(new ArrayList<String>()).isOfAnyClassIn(LinkedList.class, List.class);
types
- the types to check the actual value against.AssertionError
- if the actual value type is not in given type.NullPointerException
- if the actual value is null.NullPointerException
- if the given types is null.S isNotOfAnyClassIn(Class<?>... types)
Example:
// assertions will pass
assertThat(new HashMap<String, Integer>()).isNotOfAnyClassIn(Map.class, TreeMap.class);
assertThat(new ArrayList<String>()).isNotOfAnyClassIn(LinkedList.class, List.class);
// assertions will fail
assertThat(new HashMap<String, Integer>()).isNotOfAnyClassIn(HashMap.class, TreeMap.class);
assertThat(new ArrayList<String>()).isNotOfAnyClassIn(ArrayList.class, LinkedList.class);
types
- the types to check the actual value against.AssertionError
- if the actual value type is in given types.NullPointerException
- if the actual value is null.NullPointerException
- if the given types is null.AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>> asList()
Example :
Object sortedListAsObject = Arrays.asList(1, 2, 3);
// assertion will pass
assertThat(sortedListAsObject).asList().isSorted();
Object unsortedListAsObject = Arrays.asList(3, 1, 2);
// assertion will fail
assertThat(unsortedListAsObject).asList().isSorted();
AbstractCharSequenceAssert<?,String> asString()
Example :
Object stringAsObject = "hello world";
// assertion will pass
assertThat(stringAsObject).asString().contains("hello");
// assertion will fail
assertThat(stringAsObject).asString().contains("holla");
@Deprecated boolean equals(Object obj)
UnsupportedOperationException
if called. It is easy to accidentally call
equals(Object)
instead of isEqualTo(Object)
.equals
in class Object
UnsupportedOperationException
- if this method is called.S withThreadDumpOnError()
System.err
.
Example :
assertThat("Messi").withThreadDumpOnError().isEqualTo("Ronaldo");
will print the thread dump, something looking like:
"JDWP Command Reader"
java.lang.Thread.State: RUNNABLE
"JDWP Event Helper Thread"
java.lang.Thread.State: RUNNABLE
"JDWP Transport Listener: dt_socket"
java.lang.Thread.State: RUNNABLE
"Signal Dispatcher"
java.lang.Thread.State: RUNNABLE
"Finalizer"
java.lang.Thread.State: WAITING
at java.lang.Object.wait(Native Method)
at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135)
at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:151)
at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:189)
"Reference Handler"
java.lang.Thread.State: WAITING
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:503)
at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:133)
"main"
java.lang.Thread.State: RUNNABLE
at sun.management.ThreadImpl.dumpThreads0(Native Method)
at sun.management.ThreadImpl.dumpAllThreads(ThreadImpl.java:446)
at org.assertj.core.internal.Failures.threadDumpDescription(Failures.java:193)
at org.assertj.core.internal.Failures.printThreadDumpIfNeeded(Failures.java:141)
at org.assertj.core.internal.Failures.failure(Failures.java:91)
at org.assertj.core.internal.Objects.assertEqual(Objects.java:314)
at org.assertj.core.api.AbstractAssert.isEqualTo(AbstractAssert.java:198)
at org.assertj.examples.ThreadDumpOnErrorExample.main(ThreadDumpOnErrorExample.java:28)
S withRepresentation(Representation representation)
Representation
to describe/represent values in AssertJ error messages.
The usual to introduce a new Representation
is to extend StandardRepresentation
and override any existing toStringOf
methods that don't suit you, as an example you could control
Date
format by overriding StandardRepresentation.toStringOf(Date)
).
You can also control other types format by overriding StandardRepresentation.toStringOf(Object)
)
calling your formatting method first and then fallback to the default represention by calling super.toStringOf(Object)
.
Example :
private class Example {}
private class CustomRepresentation extends StandardRepresentation {
// override needed to hook specific formatting
@Override
public String toStringOf(Object o) {
if (o instanceof Example) return "Example";
// fallback to default formatting.
return super.toStringOf(o);
}
// change String representation
@Override
protected String toStringOf(String s) {
return "$" + s + "$";
}
}
// next assertion fails with error : "expected:<[null]> but was:<[Example]>"
Example example = new Example();
assertThat(example).withRepresentation(new CustomRepresentation())
.isNull(); // example is not null !
// next assertion fails ...
assertThat("foo").withRepresentation(new CustomRepresentation())
.startsWith("bar");
// ... with error :
Expecting:
<$foo$>
to start with:
<$bar$>
representation
- Describe/represent values in AssertJ error messages.Copyright © 2013–2016 AssertJ. All rights reserved.