public abstract class AbstractByteArrayAssert<S extends AbstractByteArrayAssert<S>> extends AbstractArrayAssert<S,byte[],Byte>
| Modifier and Type | Field and Description |
|---|---|
protected ByteArrays |
arrays |
actual, info, myself| Constructor and Description |
|---|
AbstractByteArrayAssert(byte[] actual,
Class<?> selfType) |
| Modifier and Type | Method and Description |
|---|---|
S |
contains(byte... values)
Verifies that the actual array contains the given values, in any order.
|
S |
contains(byte value,
Index index)
Verifies that the actual array contains the given value at the given index.
|
S |
contains(int... values)
Verifies that the actual array contains the given values, in any order.
|
S |
contains(int value,
Index index)
Verifies that the actual array contains the given value at the given index.
|
S |
containsExactly(byte... values)
Verifies that the actual group contains only the given values and nothing else, in order.
|
S |
containsExactly(int... values)
Verifies that the actual group contains only the given values and nothing else, in order.
|
S |
containsExactlyInAnyOrder(byte... values)
Verifies that the actual group contains exactly the given values and nothing else, in any order.
|
S |
containsExactlyInAnyOrder(int... values)
Verifies that the actual group contains exactly the given values and nothing else, in any order.
|
S |
containsOnly(byte... values)
Verifies that the actual array contains only the given values and nothing else, in any order.
|
S |
containsOnly(int... values)
Verifies that the actual array contains only the given values and nothing else, in any order.
|
S |
containsOnlyOnce(byte... values)
Verifies that the actual array contains the given values only once.
|
S |
containsOnlyOnce(int... values)
Verifies that the actual array contains the given values only once.
|
S |
containsSequence(byte... sequence)
Verifies that the actual array contains the given sequence, without any other values between them.
|
S |
containsSequence(int... sequence)
Verifies that the actual array contains the given sequence, without any other values between them.
|
S |
containsSubsequence(byte... subsequence)
Verifies that the actual array contains the given subsequence (possibly with other values between them).
|
S |
containsSubsequence(int... subsequence)
Verifies that the actual array contains the given subsequence (possibly with other values between them).
|
S |
doesNotContain(byte... values)
Verifies that the actual array does not contain the given values.
|
S |
doesNotContain(byte value,
Index index)
Verifies that the actual array does not contain the given value at the given index.
|
S |
doesNotContain(int... values)
Verifies that the actual array does not contain the given values.
|
S |
doesNotContain(int value,
Index index)
Verifies that the actual array does not contain the given value at the given index.
|
S |
doesNotHaveDuplicates()
Verifies that the actual array does not contain duplicates.
|
S |
endsWith(byte... sequence)
Verifies that the actual array ends with the given sequence of values, without any other values between them.
|
S |
endsWith(int... sequence)
Verifies that the actual array ends with the given sequence of values, without any other values between them.
|
S |
hasSameSizeAs(Iterable<?> other)
Verifies that the actual group has the same size as given
Iterable. |
S |
hasSize(int expected)
Verifies that the number of values in the actual group is equal to the given one.
|
void |
isEmpty()
Verifies that the actual group of values is empty.
|
S |
isNotEmpty()
Verifies that the actual group of values is not empty.
|
void |
isNullOrEmpty()
Verifies that the actual group of values is
null or empty. |
S |
isSorted()
Verifies that the actual array is sorted in ascending order according to the natural ordering of its elements.
|
S |
isSortedAccordingTo(Comparator<? super Byte> comparator)
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. |
S |
startsWith(byte... sequence)
Verifies that the actual array starts with the given sequence of values, without any other values between them.
|
S |
startsWith(int... sequence)
Verifies that the actual array starts with the given sequence of values, without any other values between them.
|
S |
usingDefaultElementComparator()
Revert to standard comparison for incoming assertion group element checks.
|
S |
usingElementComparator(Comparator<? super Byte> customComparator)
Use given custom comparator instead of relying on actual type A
equals method to compare group
elements for incoming assertion checks. |
hasSameSizeAs, inBinary, inHexadecimalas, as, asList, asString, describedAs, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasToString, is, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, overridingErrorMessage, setCustomRepresentation, usingComparator, usingDefaultComparator, withFailMessage, withRepresentation, withThreadDumpOnErrorprotected ByteArrays arrays
public AbstractByteArrayAssert(byte[] actual,
Class<?> selfType)
public 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();public 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();public S 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.public S 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);Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).hasSize(3);
// assertion will fail
assertThat(new byte[] { 1, 2, 3, 4 }).hasSize(3);expected - the expected number of values in the actual group.this assertion object.public S hasSameSizeAs(Iterable<?> other)
Iterable.
Examples:
// assertion will pass
assertThat(new byte[] { 1, 2 }).hasSameSizeAs(Arrays.asList(2, 3));
// assertion will fail
assertThat(new byte[] { 1, 2 }).hasSameSizeAs(Arrays.asList(1, 2, 3));other - the Iterable to compare size with actual group.this assertion object.public S contains(byte... values)
Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).contains((byte) 1, (byte) 2);
assertThat(new byte[] { 1, 2, 3 }).contains((byte) 3, (byte) 1);
assertThat(new byte[] { 1, 2, 3 }).contains((byte) 1, (byte) 3, (byte) 2);
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).contains((byte) 1, (byte) 4);
assertThat(new byte[] { 1, 2, 3 }).contains((byte) 4, (byte) 7);values - the given values.this assertion object.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.AssertionError - if the actual array is null.AssertionError - if the actual array does not contain the given values.public S contains(int... values)
Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).contains(1, 2);
assertThat(new byte[] { 1, 2, 3 }).contains(3, 1);
assertThat(new byte[] { 1, 2, 3 }).contains(1, 3, 2);
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).contains(1, 4);
assertThat(new byte[] { 1, 2, 3 }).contains(4, 7);values - the given values.this assertion object.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.AssertionError - if the actual array is null.AssertionError - if the actual array does not contain the given values.public S containsOnly(byte... values)
Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).containsOnly((byte) 1, (byte) 2, (byte) 3);
assertThat(new byte[] { 1, 2, 3 }).containsOnly((byte) 2, (byte) 3, (byte) 1);
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).containsOnly((byte) 1, (byte) 2, (byte) 3, (byte) 4);
assertThat(new byte[] { 1, 2, 3 }).containsOnly((byte) 4, (byte) 7);values - the given values.this assertion object.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.AssertionError - if the actual array is null.AssertionError - 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.public S containsOnly(int... values)
Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).containsOnly(1, 2, 3);
assertThat(new byte[] { 1, 2, 3 }).containsOnly(2, 3, 1);
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).containsOnly(1, 2, 3, 4);
assertThat(new byte[] { 1, 2, 3 }).containsOnly(4, 7);values - the given values.this assertion object.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.AssertionError - if the actual array is null.AssertionError - 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.public S containsOnlyOnce(byte... values)
Examples :
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).containsOnlyOnce((byte) 1, (byte) 2);
// assertions will fail
assertThat(new byte[] { 1, 2, 1 }).containsOnlyOnce((byte) 1);
assertThat(new byte[] { 1, 2, 3 }).containsOnlyOnce((byte) 4);
assertThat(new byte[] { 1, 2, 3, 3 }).containsOnlyOnce((byte) 0, (byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5);values - the given values.this assertion object.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.AssertionError - if the actual array is null.AssertionError - 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.public S containsOnlyOnce(int... values)
Examples :
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).containsOnlyOnce(1, 2);
// assertions will fail
assertThat(new byte[] { 1, 2, 1 }).containsOnlyOnce(1);
assertThat(new byte[] { 1, 2, 3 }).containsOnlyOnce(4);
assertThat(new byte[] { 1, 2, 3, 3 }).containsOnlyOnce(0, 1, 2, 3, 4, 5);values - the given values.this assertion object.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.AssertionError - if the actual array is null.AssertionError - 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.public S containsSequence(byte... sequence)
Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).containsSequence((byte) 1, (byte) 2);
assertThat(new byte[] { 1, 2, 3 }).containsSequence((byte) 1, (byte) 2, (byte) 3);
assertThat(new byte[] { 1, 2, 3 }).containsSequence((byte) 2, (byte) 3);
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).containsSequence((byte) 1, (byte) 3);
assertThat(new byte[] { 1, 2, 3 }).containsSequence((byte) 4, (byte) 7);sequence - the sequence of values to look for.AssertionError - if the actual array is null.AssertionError - if the given array is null.AssertionError - if the actual array does not contain the given sequence.public S containsSequence(int... sequence)
Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).containsSequence(1, 2);
assertThat(new byte[] { 1, 2, 3 }).containsSequence(1, 2, 3);
assertThat(new byte[] { 1, 2, 3 }).containsSequence(2, 3);
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).containsSequence(1, 3);
assertThat(new byte[] { 1, 2, 3 }).containsSequence(4, 7);sequence - the sequence of values to look for.AssertionError - if the actual array is null.AssertionError - if the given array is null.AssertionError - if the actual array does not contain the given sequence.public S containsSubsequence(byte... subsequence)
Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).containsSubsequence((byte) 1, (byte) 2, (byte) 3);
assertThat(new byte[] { 1, 2, 3 }).containsSubsequence((byte) 1, (byte) 2);
assertThat(new byte[] { 1, 2, 3 }).containsSubsubsequence((byte) 1, (byte) 3);
assertThat(new byte[] { 1, 2, 3 }).containsSubsequence((byte) 2, (byte) 3);
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).containsSubsequence((byte) 2, (byte) 1);
assertThat(new byte[] { 1, 2, 3 }).containsSubsequence((byte) 4, (byte) 7);subsequence - the subsequence of values to look for.AssertionError - if the actual array is null.AssertionError - if the given array is null.AssertionError - if the actual array does not contain the given subsequence.public S containsSubsequence(int... subsequence)
Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).containsSubsequence(1, 2, 3);
assertThat(new byte[] { 1, 2, 3 }).containsSubsequence(1, 2);
assertThat(new byte[] { 1, 2, 3 }).containsSubsubsequence(1, 3);
assertThat(new byte[] { 1, 2, 3 }).containsSubsequence(2, 3);
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).containsSubsequence(2, 1);
assertThat(new byte[] { 1, 2, 3 }).containsSubsequence(4, 7);subsequence - the subsequence of values to look for.AssertionError - if the actual array is null.AssertionError - if the given array is null.AssertionError - if the actual array does not contain the given subsequence.public S contains(byte value, Index index)
Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).contains((byte) 1, atIndex(O));
assertThat(new byte[] { 1, 2, 3 }).contains((byte) 3, atIndex(2));
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).contains((byte) 1, atIndex(1));
assertThat(new byte[] { 1, 2, 3 }).contains((byte) 4, atIndex(2));value - the value to look for.index - the index where the value should be stored in the actual array.AssertionError - if the actual array is null or empty.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.AssertionError - if the actual array does not contain the given value at the given index.public S contains(int value, Index index)
Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).contains(1, atIndex(O));
assertThat(new byte[] { 1, 2, 3 }).contains(3, atIndex(2));
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).contains(1, atIndex(1));
assertThat(new byte[] { 1, 2, 3 }).contains(4, atIndex(2));value - the value to look for.index - the index where the value should be stored in the actual array.AssertionError - if the actual array is null or empty.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.AssertionError - if the actual array does not contain the given value at the given index.public S doesNotContain(byte... values)
Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).doesNotContain((byte) 4);
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).doesNotContain((byte) 2);values - the given values.this assertion object.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.AssertionError - if the actual array is null.AssertionError - if the actual array contains any of the given values.public S doesNotContain(int... values)
Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).doesNotContain(4);
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).doesNotContain(2);values - the given values.this assertion object.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.AssertionError - if the actual array is null.AssertionError - if the actual array contains any of the given values.public S doesNotContain(byte value, Index index)
Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).doesNotContain((byte) 1, atIndex(1));
assertThat(new byte[] { 1, 2, 3 }).doesNotContain((byte) 2, atIndex(0));
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).doesNotContain((byte) 1, atIndex(0));
assertThat(new byte[] { 1, 2, 3 }).doesNotContain((byte) 2, atIndex(1));value - the value to look for.index - the index where the value should be stored in the actual array.AssertionError - if the actual array is null.NullPointerException - if the given Index is null.AssertionError - if the actual array contains the given value at the given index.public S doesNotContain(int value, Index index)
Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).doesNotContain(1, atIndex(1));
assertThat(new byte[] { 1, 2, 3 }).doesNotContain(2, atIndex(0));
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).doesNotContain(1, atIndex(0));
assertThat(new byte[] { 1, 2, 3 }).doesNotContain(2, atIndex(1));value - the value to look for.index - the index where the value should be stored in the actual array.AssertionError - if the actual array is null.NullPointerException - if the given Index is null.AssertionError - if the actual array contains the given value at the given index.public S doesNotHaveDuplicates()
Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).doesNotHaveDuplicates();
// assertion will fail
assertThat(new byte[] { 1, 1, 2, 3 }).doesNotHaveDuplicates();this assertion object.AssertionError - if the actual array is null.AssertionError - if the actual array contains duplicates.public S startsWith(byte... sequence)
containsSequence(byte...)Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).startsWith((byte) 1, (byte) 2);
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).startsWith((byte) 2, (byte) 3);sequence - the sequence of values to look for.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.AssertionError - if the actual array is null.AssertionError - if the actual array does not start with the given sequence.public S startsWith(int... sequence)
containsSequence(byte...)Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).startsWith(1, 2);
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).startsWith(2, 3);sequence - the sequence of values to look for.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.AssertionError - if the actual array is null.AssertionError - if the actual array does not start with the given sequence.public S endsWith(byte... sequence)
containsSequence(byte...)Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).endsWith((byte) 2, (byte) 3);
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).endsWith((byte) 3, (byte) 4);sequence - the sequence of values to look for.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.AssertionError - if the actual array is null.AssertionError - if the actual array does not end with the given sequence.public S endsWith(int... sequence)
containsSequence(byte...)Example:
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).endsWith(2, 3);
// assertion will fail
assertThat(new byte[] { 1, 2, 3 }).endsWith(3, 4);sequence - the sequence of values to look for.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.AssertionError - if the actual array is null.AssertionError - if the actual array does not end with the given sequence.public S isSorted()
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 :
this assertion object.public S isSortedAccordingTo(Comparator<? super Byte> comparator)
comparator - the Comparator used to compare array elementsthis assertion object.public S usingElementComparator(Comparator<? super Byte> 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.public S usingDefaultElementComparator()
This method should be used to disable a custom comparison strategy set by calling
EnumerableAssert.usingElementComparator(Comparator).
this assertion object.public S containsExactly(byte... values)
Example :
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).containsExactly((byte) 1, (byte) 2, (byte) 3);
// assertion will fail as actual and expected order differ
assertThat(new byte[] { 1, 2, 3 }).containsExactly((byte) 2, (byte) 1, (byte) 3);values - the given values.this assertion object.NullPointerException - if the given argument is null.AssertionError - if the actual group is null.AssertionError - 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.public S containsExactly(int... values)
Example :
// assertion will pass
assertThat(new byte[] { 1, 2, 3 }).containsExactly(1, 2, 3);
// assertion will fail as actual and expected order differ
assertThat(new byte[] { 1, 2, 3 }).containsExactly(2, 1, 3);values - the given values.this assertion object.NullPointerException - if the given argument is null.AssertionError - if the actual group is null.AssertionError - 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.public S containsExactlyInAnyOrder(byte... values)
Example :
// assertions will pass
assertThat(new byte[] { 1, 2 }).containsExactlyInAnyOrder((byte) 1, (byte) 2);
assertThat(new byte[] { 1, 2, 1 }).containsExactlyInAnyOrder((byte) 1, (byte) 1, (byte) 2);
// assertions will fail
assertThat(new byte[] { 1, 2 }).containsExactlyInAnyOrder((byte) 1);
assertThat(new byte[] { 1 }).containsExactlyInAnyOrder((byte) 1, (byte) 2);
assertThat(new byte[] { 1, 2, 1 }).containsExactlyInAnyOrder((byte) 1, (byte) 2);values - the given values.this assertion object.NullPointerException - if the given argument is null.AssertionError - if the actual group is null.AssertionError - 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.public S containsExactlyInAnyOrder(int... values)
Example :
// assertions will pass
assertThat(new byte[] { 1, 2 }).containsExactlyInAnyOrder(1, 2);
assertThat(new byte[] { 1, 2, 1 }).containsExactlyInAnyOrder(1, 1, 2);
// assertions will fail
assertThat(new byte[] { 1, 2 }).containsExactlyInAnyOrder(1);
assertThat(new byte[] { 1 }).containsExactlyInAnyOrder(1, 2);
assertThat(new byte[] { 1, 2, 1 }).containsExactlyInAnyOrder(1, 2);values - the given values.this assertion object.NullPointerException - if the given argument is null.AssertionError - if the actual group is null.AssertionError - 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.Copyright © 2013–2016 AssertJ. All rights reserved.