AssertJ Core 3.26.0 · org.assertj.core.api.AbstractDoubleArrayAssert

Modifier and Type	Field and Description
protected DoubleArrays	arrays

Access	Constructor and Description
protected	AbstractDoubleArrayAssert(double[] actual, Class<?> selfType)

Method Summary

Modifier and Type	Method and Description
public SELF	Returns: `this` assertion object. contains(double... the given values. values) Verifies that the actual array contains the given values, in any order.
public SELF	Returns: `this` assertion object. contains(Double[] the given values. values) Verifies that the actual array contains the values of the given array, in any order.
public SELF	Returns: `this` assertion object. contains(double[] the given values. values, Offset<Double> the precision under which the value may vary precision) Verifies that the actual array contains the given values, in any order, the comparison is done at the given precision/offset set with `Assertions#withPrecision(Double)`.
public SELF	Returns: `this` assertion object. contains(Double[] the given values. values, Offset<Double> the precision under which the value may vary precision) Verifies that the actual array contains the values of the given array, in any order, the comparison is done at the given precision/offset set with `Assertions#withPrecision(Double)`.
public SELF	Returns: `this` assertion object. contains(double the value to look for. value, Index the index where the value should be stored in the actual array. index) Verifies that the actual array contains the given value at the given index.
public SELF	Returns: `this` assertion object. contains(double the value to look for. value, Index the index where the value should be stored in the actual array. index, Offset<Double> the precision under which the value may vary. precision) Verifies that the actual array contains the given value at the given index.
public SELF	Returns: `this` assertion object. containsAnyOf(double... the values whose at least one which is expected to be in the array under test. values) Verifies that the actual array contains at least one of the given values.
public SELF	Returns: `this` assertion object. containsAnyOf(Double[] the values whose at least one which is expected to be in the array under test. values) Verifies that the actual array contains at least one of the values of the given array.
public SELF	Returns: `this` assertion object. containsExactly(double... the given values. values) Verifies that the actual group contains only the given values and nothing else, in order.
public SELF	Returns: `this` assertion object. containsExactly(Double[] the given values. values) Verifies that the actual group contains only the values of the given array and nothing else, in order.
public SELF	Returns: `this` assertion object. containsExactly(double[] the given values. values, Offset<Double> the precision under which the values may vary. precision) Verifies that the actual group contains only the given values and nothing else, in order.
public SELF	Returns: `this` assertion object. containsExactly(Double[] the given values. values, Offset<Double> the precision under which the values may vary. precision) Verifies that the actual group contains only the values of the given array and nothing else, in order.
public SELF	Returns: `this` assertion object. containsExactlyInAnyOrder(double... the given values. values) Verifies that the actual group contains exactly the given values and nothing else, in any order.
public SELF	Returns: `this` assertion object. containsExactlyInAnyOrder(Double[] the given values. values) Verifies that the actual group contains exactly the values of the given array and nothing else, in any order.
public SELF	Returns: `this` assertion object. containsOnly(double... the given values. values) Verifies that the actual array contains only the given values and nothing else, in any order.
public SELF	Returns: `this` assertion object. containsOnly(Double[] the given values. values) Verifies that the actual array contains only the values of the given array and nothing else, in any order.
public SELF	Returns: `this` assertion object. containsOnly(double[] the given values. values, Offset<Double> the precision under which the value may vary precision) Verifies that the actual array contains only the given values and nothing else, in any order.
public SELF	Returns: `this` assertion object. containsOnly(Double[] the given values. values, Offset<Double> the precision under which the value may vary precision) Verifies that the actual array contains only the values of the given array and nothing else, in any order.
public SELF	Returns: `this` assertion object. containsOnlyOnce(double... the given values. values) Verifies that the actual array contains the given values only once.
public SELF	Returns: `this` assertion object. containsOnlyOnce(Double[] the given values. values) Verifies that the actual array contains the values of the given array only once.
public SELF	Returns: `this` assertion object. containsOnlyOnce(double[] the given values. values, Offset<Double> the precision under which the value may vary precision) Verifies that the actual array contains the given values only once.
public SELF	Returns: `this` assertion object. containsOnlyOnce(Double[] the given values. values, Offset<Double> the precision under which the value may vary precision) Verifies that the actual array contains the values of the given array only once.
public SELF	Returns: `this` assertion object. containsSequence(double... the sequence of values to look for. sequence) Verifies that the actual array contains the given sequence, without any other values between them.
public SELF	Returns: myself assertion object. containsSequence(Double[] the sequence of values to look for. sequence) Verifies that the actual array contains the given sequence, without any other values between them.
public SELF	Returns: `this` assertion object. containsSequence(double[] the sequence of values to look for. sequence, Offset<Double> the precision under which the value may vary precision) Verifies that the actual array contains the given sequence, without any other values between them.
public SELF	Returns: `this` assertion object. containsSequence(Double[] the sequence of values to look for. sequence, Offset<Double> the precision under which the value may vary precision) Verifies that the actual array contains the given sequence, without any other values between them.
public SELF	Returns: `this` assertion object. containsSubsequence(double... the subsequence of values to look for. subsequence) Verifies that the actual array contains the given subsequence (possibly with other values between them).
public SELF	Returns: myself assertion object. containsSubsequence(Double[] the subsequence of values to look for. subsequence) Verifies that the actual array contains the given subsequence (possibly with other values between them).
public SELF	Returns: `this` assertion object. containsSubsequence(double[] the subsequence of values to look for. subsequence, Offset<Double> the precision under which the value may vary. precision) Verifies that the actual array contains the given subsequence (possibly with other values between them).
public SELF	Returns: `this` assertion object. containsSubsequence(Double[] the subsequence of values to look for. subsequence, Offset<Double> the precision under which the value may vary. precision) Verifies that the actual array contains the given subsequence (possibly with other values between them).
public SELF	Returns: `this` assertion object. doesNotContain(double... the given values. values) Verifies that the actual array does not contain the given values.
public SELF	Returns: `this` assertion object. doesNotContain(Double[] the given values. values) Verifies that the actual array does not contain the values of the given array.
public SELF	Returns: `this` assertion object. doesNotContain(double[] the given values. values, Offset<Double> the precision under which the values may vary. precision) Verifies that the actual array does not contain the given values.
public SELF	Returns: `this` assertion object. doesNotContain(Double[] the given values. values, Offset<Double> the precision under which the values may vary. precision) Verifies that the actual array does not contain the values of the given array.
public SELF	Returns: `this` assertion object. doesNotContain(double the value to look for. value, Index the index where the value should be stored in the actual array. index) Verifies that the actual array does not contain the given value at the given index.
public SELF	Returns: `this` assertion object. doesNotContain(double the value to look for. value, Index the index where the value should be stored in the actual array. index, Offset<Double> the precision under which the values may vary. precision) Verifies that the actual array does not contain the given value at the given index.
public SELF	Returns: `this` assertion object. doesNotHaveDuplicates() Verifies that the actual array does not contain duplicates.
public SELF	Returns: `this` assertion object. doesNotHaveDuplicates(Offset<Double> the precision under which the values may vary. precision) Verifies that the actual array does not contain duplicates.
public SELF	Returns: `this` assertion object. endsWith(double... the sequence of values to look for. sequence) Verifies that the actual array ends with the given sequence of values, without any other values between them.
public SELF	Returns: myself assertion object. endsWith(Double[] the sequence of values to look for. sequence) Verifies that the actual array ends with the given sequence of values, without any other values between them.
public SELF	Returns: `this` assertion object. endsWith(double[] the sequence of values to look for. values, Offset<Double> the precision under which the values may vary. precision) Verifies that the actual array ends with the given sequence of values, without any other values between them.
public SELF	Returns: `this` assertion object. endsWith(Double[] the sequence of values to look for. values, Offset<Double> the precision under which the values may vary. precision) Verifies that the actual array ends with the given sequence of values, without any other values between them.
public SELF	hasSameSizeAs(Iterable<?> the `Iterable` to compare size with actual group. other) Implements org.assertj.core.api.EnumerableAssert.hasSameSizeAs. Verifies that the actual group has the same size as given `Iterable`.
public SELF	hasSize(int the expected number of values in the actual group. expected) Implements org.assertj.core.api.EnumerableAssert.hasSize. Verifies that the number of values in the actual group is equal to the given one.
public SELF	Returns: `this` assertion object. hasSizeBetween(int the lower boundary compared to which actual size should be greater than or equal to. lowerBoundary, int the higher boundary compared to which actual size should be less than or equal to. higherBoundary) Implements org.assertj.core.api.EnumerableAssert.hasSizeBetween. Verifies that the number of values in the actual group is between the given boundaries (inclusive).
public SELF	Returns: `this` assertion object. hasSizeGreaterThan(int the given value to compare the actual size to. boundary) Implements org.assertj.core.api.EnumerableAssert.hasSizeGreaterThan. Verifies that the number of values in the actual array is greater than the given boundary.
public SELF	Returns: `this` assertion object. hasSizeGreaterThanOrEqualTo(int the given value to compare the actual size to. boundary) 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.
public SELF	Returns: `this` assertion object. hasSizeLessThan(int the given value to compare the actual size to. boundary) Implements org.assertj.core.api.EnumerableAssert.hasSizeLessThan. Verifies that the number of values in the actual array is less than the given boundary.
public SELF	Returns: `this` assertion object. hasSizeLessThanOrEqualTo(int the given value to compare the actual size to. boundary) 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.
public void	isEmpty() Implements org.assertj.core.api.EnumerableAssert.isEmpty. Verifies that the actual group of values is empty.
public SELF	isNotEmpty() Implements org.assertj.core.api.EnumerableAssert.isNotEmpty. Verifies that the actual group of values is not empty.
public void	isNullOrEmpty() Implements org.assertj.core.api.EnumerableAssert.isNullOrEmpty. Verifies that the actual group of values is `null` or empty.
public SELF	isSorted() Implements org.assertj.core.api.ArraySortedAssert.isSorted. Verifies that the actual array is sorted in ascending order according to the natural ordering of its elements.
public SELF	isSortedAccordingTo(Comparator<? super Double> the `Comparator` used to compare array elements comparator) Implements org.assertj.core.api.ArraySortedAssert.isSortedAccordingTo. Verifies that the actual array is sorted according to the given comparator.
public SELF	Returns: `this` assertion object. startsWith(double... the sequence of values to look for. sequence) Verifies that the actual array starts with the given sequence of values, without any other values between them.
public SELF	Returns: myself assertion object. startsWith(Double[] the sequence of values to look for. sequence) Verifies that the actual array starts with the given sequence of values, without any other values between them.
public SELF	Returns: `this` assertion object. startsWith(double[] the sequence of values to look for. values, Offset<Double> the precision under which the values may vary. precision) Verifies that the actual array starts with the given sequence of values, without any other values between them.
public SELF	Returns: `this` assertion object. startsWith(Double[] the sequence of values to look for. values, Offset<Double> the precision under which the values may vary. precision) Verifies that the actual array starts with the given sequence of values, without any other values between them.
private static double[]	toPrimitiveDoubleArray(Double[] values)
public SELF	Returns: `this` assertion object. usingComparatorWithPrecision(Double precision used to compare `Double`. precision) Create a `Double` comparator which compares double at the given precision and pass it to `usingElementComparator(Comparator)`.
public SELF	usingDefaultElementComparator() Implements org.assertj.core.api.EnumerableAssert.usingDefaultElementComparator. Revert to standard comparison for incoming assertion group element checks.
public SELF	usingElementComparator(Comparator<? super Double> the comparator to use for incoming assertion checks. customComparator) Implements 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.

Inherited from org.assertj.core.api.AbstractArrayAssert:: requireNonNullParameter

public abstract Class AbstractDoubleArrayAssert<SELF extends AbstractDoubleArrayAssert<SELF>>

Field Summary

Constructor Summary

Method Summary