SELF |
AbstractDoubleArrayAssert.contains(double[] values,
Offset<Double> 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) .
|
SELF |
AbstractDoubleArrayAssert.contains(double value,
Index index,
Offset<Double> precision) |
Verifies that the actual array contains the given value at the given index.
|
SELF |
AbstractDoubleArrayAssert.contains(Double[] values,
Offset<Double> 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) .
|
SELF |
AbstractFloatArrayAssert.contains(float[] values,
Offset<Float> 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(Float) .
|
SELF |
AbstractFloatArrayAssert.contains(float value,
Index index,
Offset<Float> precision) |
Verifies that the actual array contains the given value at the given index.
|
SELF |
AbstractFloatArrayAssert.contains(Float[] values,
Offset<Float> 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(Float) .
|
SELF |
AbstractDoubleArrayAssert.containsExactly(double[] values,
Offset<Double> precision) |
Verifies that the actual group contains only the given values and nothing else, in order.
|
SELF |
AbstractDoubleArrayAssert.containsExactly(Double[] values,
Offset<Double> precision) |
Verifies that the actual group contains only the values of the given array and nothing else, in order.
|
SELF |
AbstractFloatArrayAssert.containsExactly(float[] values,
Offset<Float> precision) |
Verifies that the actual group contains only the given values and nothing else, in order.
|
SELF |
AbstractFloatArrayAssert.containsExactly(Float[] values,
Offset<Float> precision) |
Verifies that the actual group contains only the values of the given array and nothing else, in order.
|
SELF |
AbstractDoubleArrayAssert.containsOnly(double[] values,
Offset<Double> precision) |
Verifies that the actual array contains only the given values and nothing else, in any order.
|
SELF |
AbstractDoubleArrayAssert.containsOnly(Double[] values,
Offset<Double> precision) |
Verifies that the actual array contains only the values of the given array and nothing else, in any order.
|
SELF |
AbstractFloatArrayAssert.containsOnly(float[] values,
Offset<Float> precision) |
Verifies that the actual array contains only the given values and nothing else, in any order.
|
SELF |
AbstractFloatArrayAssert.containsOnly(Float[] values,
Offset<Float> precision) |
Verifies that the actual array contains only the values of the given array and nothing else, in any order.
|
SELF |
AbstractDoubleArrayAssert.containsOnlyOnce(double[] values,
Offset<Double> precision) |
Verifies that the actual array contains the given values only once.
|
SELF |
AbstractDoubleArrayAssert.containsOnlyOnce(Double[] values,
Offset<Double> precision) |
Verifies that the actual array contains the values of the given array only once.
|
SELF |
AbstractFloatArrayAssert.containsOnlyOnce(float[] values,
Offset<Float> precision) |
Verifies that the actual array contains the given values only once.
|
SELF |
AbstractFloatArrayAssert.containsOnlyOnce(Float[] values,
Offset<Float> precision) |
Verifies that the actual array contains the values of the given array only once.
|
SELF |
AbstractDoubleArrayAssert.containsSequence(double[] sequence,
Offset<Double> precision) |
Verifies that the actual array contains the given sequence, without any other values between them.
|
SELF |
AbstractDoubleArrayAssert.containsSequence(Double[] sequence,
Offset<Double> precision) |
Verifies that the actual array contains the given sequence, without any other values between them.
|
SELF |
AbstractFloatArrayAssert.containsSequence(float[] sequence,
Offset<Float> precision) |
Verifies that the actual array contains the given sequence, without any other values between them.
|
SELF |
AbstractFloatArrayAssert.containsSequence(Float[] sequence,
Offset<Float> precision) |
Verifies that the actual array contains the given sequence, without any other values between them.
|
SELF |
AbstractDoubleArrayAssert.containsSubsequence(double[] subsequence,
Offset<Double> precision) |
Verifies that the actual array contains the given subsequence (possibly with other values between them).
|
SELF |
AbstractDoubleArrayAssert.containsSubsequence(Double[] subsequence,
Offset<Double> precision) |
Verifies that the actual array contains the given subsequence (possibly with other values between them).
|
SELF |
AbstractFloatArrayAssert.containsSubsequence(float[] subsequence,
Offset<Float> precision) |
Verifies that the actual array contains the given subsequence (possibly with other values between them).
|
SELF |
AbstractFloatArrayAssert.containsSubsequence(Float[] subsequence,
Offset<Float> precision) |
Verifies that the actual array contains the given subsequence (possibly with other values between them).
|
SELF |
AbstractDoubleArrayAssert.doesNotContain(double[] values,
Offset<Double> precision) |
Verifies that the actual array does not contain the given values.
|
SELF |
AbstractDoubleArrayAssert.doesNotContain(double value,
Index index,
Offset<Double> precision) |
Verifies that the actual array does not contain the given value at the given index.
|
SELF |
AbstractDoubleArrayAssert.doesNotContain(Double[] values,
Offset<Double> precision) |
Verifies that the actual array does not contain the values of the given array.
|
SELF |
AbstractFloatArrayAssert.doesNotContain(float[] values,
Offset<Float> precision) |
Verifies that the actual array does not contain the given values.
|
SELF |
AbstractFloatArrayAssert.doesNotContain(float value,
Index index,
Offset<Float> precision) |
Verifies that the actual array does not contain the given value at the given index.
|
SELF |
AbstractFloatArrayAssert.doesNotContain(Float[] values,
Offset<Float> precision) |
Verifies that the actual array does not contain the values of the given array.
|
SELF |
AbstractDoubleArrayAssert.doesNotHaveDuplicates(Offset<Double> precision) |
Verifies that the actual array does not contain duplicates.
|
SELF |
AbstractFloatArrayAssert.doesNotHaveDuplicates(Offset<Float> precision) |
Verifies that the actual array does not contain duplicates.
|
SELF |
AbstractDoubleArrayAssert.endsWith(double[] values,
Offset<Double> precision) |
Verifies that the actual array ends with the given sequence of values, without any other values between them.
|
SELF |
AbstractDoubleArrayAssert.endsWith(Double[] values,
Offset<Double> precision) |
Verifies that the actual array ends with the given sequence of values, without any other values between them.
|
SELF |
AbstractFloatArrayAssert.endsWith(float[] values,
Offset<Float> precision) |
Verifies that the actual array ends with the given sequence of values, without any other values between them.
|
SELF |
AbstractFloatArrayAssert.endsWith(Float[] values,
Offset<Float> precision) |
Verifies that the actual array ends with the given sequence of values, without any other values between them.
|
SELF |
AbstractOptionalDoubleAssert.hasValueCloseTo(Double expectedValue,
Offset<Double> offset) |
Verifies that the actual OptionalDouble has the value close to the argument.
|
AtomicIntegerAssert |
AtomicIntegerAssert.hasValueCloseTo(int expected,
Offset<Integer> offset) |
Verifies that the actual atomic has a value close to the given one within the given offset.
|
AtomicLongAssert |
AtomicLongAssert.hasValueCloseTo(long expected,
Offset<Long> offset) |
Verifies that the actual atomic has a value close to the given one within the given offset.
|
SELF |
AbstractBigDecimalAssert.isCloseTo(BigDecimal expected,
Offset<BigDecimal> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
AbstractBigIntegerAssert.isCloseTo(BigInteger expected,
Offset<BigInteger> offset) |
Verifies that the actual number is close to the given one within the given offset.
|
SELF |
AbstractByteAssert.isCloseTo(byte expected,
Offset<Byte> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
AbstractByteAssert.isCloseTo(Byte expected,
Offset<Byte> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
AbstractDoubleAssert.isCloseTo(double expected,
Offset<Double> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
AbstractDoubleAssert.isCloseTo(Double expected,
Offset<Double> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
AbstractFloatAssert.isCloseTo(float expected,
Offset<Float> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
AbstractFloatAssert.isCloseTo(Float expected,
Offset<Float> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
AbstractIntegerAssert.isCloseTo(int expected,
Offset<Integer> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
AbstractIntegerAssert.isCloseTo(Integer expected,
Offset<Integer> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
AbstractLongAdderAssert.isCloseTo(Long expected,
Offset<Long> offset) |
|
SELF |
AbstractLongAssert.isCloseTo(long expected,
Offset<Long> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
AbstractLongAssert.isCloseTo(Long expected,
Offset<Long> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
AbstractShortAssert.isCloseTo(short expected,
Offset<Short> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
AbstractShortAssert.isCloseTo(Short expected,
Offset<Short> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
FloatingPointNumberAssert.isCloseTo(ACTUAL expected,
Offset<ACTUAL> offset) |
Verifies that the actual number is close to the given one within the given offset.
If difference is equal to offset value, assertion is considered valid.
|
SELF |
NumberAssert.isCloseTo(ACTUAL expected,
Offset<ACTUAL> offset) |
Verifies that the actual number is close to the given one within the given offset.
If difference is equal to offset value, assertion is considered valid.
|
SELF |
AbstractDoubleAssert.isEqualTo(double expected,
Offset<Double> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
AbstractDoubleAssert.isEqualTo(Double expected,
Offset<Double> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
AbstractFloatAssert.isEqualTo(float expected,
Offset<Float> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
AbstractFloatAssert.isEqualTo(Float expected,
Offset<Float> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
FloatingPointNumberAssert.isEqualTo(ACTUAL expected,
Offset<ACTUAL> offset) |
Verifies that the actual number is close to the given one within the given offset value.
|
SELF |
AbstractBigDecimalAssert.isNotCloseTo(BigDecimal expected,
Offset<BigDecimal> offset) |
Verifies that the actual number is not close to the given one by less than the given offset.
|
SELF |
AbstractBigIntegerAssert.isNotCloseTo(BigInteger expected,
Offset<BigInteger> offset) |
Verifies that the actual number is not close to the given one by less than the given offset.
|
SELF |
AbstractByteAssert.isNotCloseTo(byte expected,
Offset<Byte> offset) |
Verifies that the actual number is not close to the given one by less than the given offset.
|
SELF |
AbstractByteAssert.isNotCloseTo(Byte expected,
Offset<Byte> offset) |
Verifies that the actual number is not close to the given one by less than the given offset.
|
SELF |
AbstractDoubleAssert.isNotCloseTo(double expected,
Offset<Double> offset) |
Verifies that the actual number is not close to the given one by less than the given offset.
|
SELF |
AbstractDoubleAssert.isNotCloseTo(Double expected,
Offset<Double> offset) |
Verifies that the actual number is not close to the given one by less than the given offset.
|
SELF |
AbstractFloatAssert.isNotCloseTo(float expected,
Offset<Float> offset) |
Verifies that the actual number is not close to the given one by less than the given offset.
|
SELF |
AbstractFloatAssert.isNotCloseTo(Float expected,
Offset<Float> offset) |
Verifies that the actual number is not close to the given one by less than the given offset.
|
SELF |
AbstractIntegerAssert.isNotCloseTo(int expected,
Offset<Integer> offset) |
Verifies that the actual number is not close to the given one by less than the given offset.
|
SELF |
AbstractIntegerAssert.isNotCloseTo(Integer expected,
Offset<Integer> offset) |
Verifies that the actual number is not close to the given one by less than the given offset.
|
SELF |
AbstractLongAdderAssert.isNotCloseTo(Long expected,
Offset<Long> offset) |
|
SELF |
AbstractLongAssert.isNotCloseTo(long expected,
Offset<Long> offset) |
Verifies that the actual number is not close to the given one by less than the given offset.
|
SELF |
AbstractLongAssert.isNotCloseTo(Long expected,
Offset<Long> offset) |
Verifies that the actual number is not close to the given one by less than the given offset.
|
SELF |
AbstractShortAssert.isNotCloseTo(short expected,
Offset<Short> offset) |
Verifies that the actual number is not close to the given one by less than the given offset.
|
SELF |
AbstractShortAssert.isNotCloseTo(Short expected,
Offset<Short> offset) |
Verifies that the actual number is not close to the given one by less than the given offset.
|
SELF |
FloatingPointNumberAssert.isNotCloseTo(ACTUAL expected,
Offset<ACTUAL> offset) |
Verifies that the actual number is not close to the given one by less than the given offset.
If the difference is equal to the offset value, the assertion fails.
|
SELF |
NumberAssert.isNotCloseTo(ACTUAL expected,
Offset<ACTUAL> offset) |
Verifies that the actual number is not close to the given one within the given offset.
If the difference is equal to the offset value, the assertion fails.
|
SELF |
AbstractDoubleArrayAssert.startsWith(double[] values,
Offset<Double> precision) |
Verifies that the actual array starts with the given sequence of values, without any other values between them.
|
SELF |
AbstractDoubleArrayAssert.startsWith(Double[] values,
Offset<Double> precision) |
Verifies that the actual array starts with the given sequence of values, without any other values between them.
|
SELF |
AbstractFloatArrayAssert.startsWith(float[] values,
Offset<Float> precision) |
Verifies that the actual array starts with the given sequence of values, without any other values between them.
|
SELF |
AbstractFloatArrayAssert.startsWith(Float[] values,
Offset<Float> precision) |
Verifies that the actual array starts with the given sequence of values, without any other values between them.
|