Package | Description |
---|---|
org.assertj.core.api | |
org.assertj.core.data | |
org.assertj.core.error | |
org.assertj.core.internal |
Modifier and Type | Method and Description |
---|---|
static Offset<java.math.BigDecimal> |
Assertions.byLessThan(java.math.BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
static Offset<java.math.BigDecimal> |
Java6Assertions.byLessThan(java.math.BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
static Offset<java.math.BigInteger> |
Assertions.byLessThan(java.math.BigInteger value)
Assertions entry point for BigInteger
Offset to use with isCloseTo assertions. |
static Offset<java.math.BigInteger> |
Java6Assertions.byLessThan(java.math.BigInteger value)
Assertions entry point for BigInteger
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Byte> |
Assertions.byLessThan(java.lang.Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Byte> |
Java6Assertions.byLessThan(java.lang.Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Double> |
Assertions.byLessThan(java.lang.Double value)
Alias for
Assertions.offset(Double) to use with isCloseTo assertions. |
static Offset<java.lang.Double> |
Java6Assertions.byLessThan(java.lang.Double value)
Alias for
Java6Assertions.offset(Double) to use with isCloseTo assertions. |
static Offset<java.lang.Float> |
Assertions.byLessThan(java.lang.Float value)
Alias for
Assertions.offset(Float) to use with isCloseTo assertions. |
static Offset<java.lang.Float> |
Java6Assertions.byLessThan(java.lang.Float value)
Alias for
Java6Assertions.offset(Float) to use with isCloseTo assertions. |
static Offset<java.lang.Integer> |
Assertions.byLessThan(java.lang.Integer value)
Assertions entry point for Integer
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Integer> |
Java6Assertions.byLessThan(java.lang.Integer value)
Assertions entry point for Integer
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Long> |
Assertions.byLessThan(java.lang.Long value)
Assertions entry point for Long
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Long> |
Java6Assertions.byLessThan(java.lang.Long value)
Assertions entry point for Long
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Short> |
Assertions.byLessThan(java.lang.Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Short> |
Java6Assertions.byLessThan(java.lang.Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Double> |
Assertions.offset(java.lang.Double value)
Assertions entry point for double
Offset . |
default Offset<java.lang.Double> |
WithAssertions.offset(java.lang.Double value)
Delegate call to
Assertions.offset(Double) |
static Offset<java.lang.Double> |
AssertionsForClassTypes.offset(java.lang.Double value)
Assertions entry point for double
Offset . |
static Offset<java.lang.Double> |
Java6Assertions.offset(java.lang.Double value)
Assertions entry point for double
Offset . |
static Offset<java.lang.Float> |
Assertions.offset(java.lang.Float value)
Assertions entry point for float
Offset . |
default Offset<java.lang.Float> |
WithAssertions.offset(java.lang.Float value)
Delegate call to
Assertions.offset(Float) |
static Offset<java.lang.Float> |
AssertionsForClassTypes.offset(java.lang.Float value)
Assertions entry point for float
Offset . |
static Offset<java.lang.Float> |
Java6Assertions.offset(java.lang.Float value)
Assertions entry point for float
Offset . |
static Offset<java.math.BigDecimal> |
Assertions.within(java.math.BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
default Offset<java.math.BigDecimal> |
WithAssertions.within(java.math.BigDecimal actual)
Delegate call to
Assertions.within(BigDecimal) |
static Offset<java.math.BigDecimal> |
AssertionsForClassTypes.within(java.math.BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
static Offset<java.math.BigDecimal> |
Java6Assertions.within(java.math.BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
static Offset<java.math.BigInteger> |
Assertions.within(java.math.BigInteger value)
Assertions entry point for BigInteger
Offset to use with isCloseTo assertions. |
static Offset<java.math.BigInteger> |
Java6Assertions.within(java.math.BigInteger value)
Assertions entry point for BigInteger
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Byte> |
Assertions.within(java.lang.Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Byte> |
AssertionsForClassTypes.within(java.lang.Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Byte> |
Java6Assertions.within(java.lang.Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Double> |
Assertions.within(java.lang.Double value)
Alias for
Assertions.offset(Double) to use with isCloseTo assertions. |
default Offset<java.lang.Double> |
WithAssertions.within(java.lang.Double actual)
Delegate call to
Assertions.within(Double) |
static Offset<java.lang.Double> |
AssertionsForClassTypes.within(java.lang.Double value)
Alias for
AssertionsForClassTypes.offset(Double) to use with isCloseTo assertions. |
static Offset<java.lang.Double> |
Java6Assertions.within(java.lang.Double value)
Alias for
Java6Assertions.offset(Double) to use with isCloseTo assertions. |
static Offset<java.lang.Float> |
Assertions.within(java.lang.Float value)
Alias for
Assertions.offset(Float) to use with isCloseTo assertions. |
default Offset<java.lang.Float> |
WithAssertions.within(java.lang.Float actual)
Delegate call to
Assertions.within(Float) |
static Offset<java.lang.Float> |
AssertionsForClassTypes.within(java.lang.Float value)
Alias for
AssertionsForClassTypes.offset(Float) to use with isCloseTo assertions. |
static Offset<java.lang.Float> |
Java6Assertions.within(java.lang.Float value)
Alias for
Java6Assertions.offset(Float) to use with isCloseTo assertions. |
static Offset<java.lang.Integer> |
Assertions.within(java.lang.Integer value)
Assertions entry point for Integer
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Integer> |
AssertionsForClassTypes.within(java.lang.Integer value)
Assertions entry point for Integer
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Integer> |
Java6Assertions.within(java.lang.Integer value)
Assertions entry point for Integer
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Long> |
Assertions.within(java.lang.Long value)
Assertions entry point for Long
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Long> |
AssertionsForClassTypes.within(java.lang.Long value)
Assertions entry point for Long
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Long> |
Java6Assertions.within(java.lang.Long value)
Assertions entry point for Long
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Short> |
Assertions.within(java.lang.Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Short> |
AssertionsForClassTypes.within(java.lang.Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Short> |
Java6Assertions.within(java.lang.Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
static Offset<java.lang.Double> |
Assertions.withPrecision(java.lang.Double value)
Alias for
Assertions.offset(Double) to use with real number assertions. |
static Offset<java.lang.Float> |
Assertions.withPrecision(java.lang.Float value)
Alias for
Assertions.offset(Float) to use with real number assertions. |
Modifier and Type | Method and Description |
---|---|
SELF |
AbstractDoubleArrayAssert.contains(double[] values,
Offset<java.lang.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<java.lang.Double> precision)
Verifies that the actual array contains the given value at the given index.
|
SELF |
AbstractFloatArrayAssert.contains(float[] values,
Offset<java.lang.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<java.lang.Float> precision)
Verifies that the actual array contains the given value at the given index.
|
SELF |
AbstractDoubleArrayAssert.containsExactly(double[] values,
Offset<java.lang.Double> precision)
Verifies that the actual group contains only the given values and nothing else, in order.
|
SELF |
AbstractFloatArrayAssert.containsExactly(float[] values,
Offset<java.lang.Float> precision)
Verifies that the actual group contains only the given values and nothing else, in order.
|
SELF |
AbstractDoubleArrayAssert.containsOnly(double[] values,
Offset<java.lang.Double> precision)
Verifies that the actual array contains only the given values and nothing else, in any order.
|
SELF |
AbstractFloatArrayAssert.containsOnly(float[] values,
Offset<java.lang.Float> precision)
Verifies that the actual array contains only the given values and nothing else, in any order.
|
SELF |
AbstractDoubleArrayAssert.containsOnlyOnce(double[] values,
Offset<java.lang.Double> precision)
Verifies that the actual array contains the given values only once.
|
SELF |
AbstractFloatArrayAssert.containsOnlyOnce(float[] values,
Offset<java.lang.Float> precision)
Verifies that the actual array contains the given values only once.
|
SELF |
AbstractDoubleArrayAssert.containsSequence(double[] sequence,
Offset<java.lang.Double> precision)
Verifies that the actual array contains the given sequence, without any other values between them.
|
SELF |
AbstractFloatArrayAssert.containsSequence(float[] sequence,
Offset<java.lang.Float> precision)
Verifies that the actual array contains the given sequence, without any other values between them.
|
SELF |
AbstractDoubleArrayAssert.containsSubsequence(double[] subsequence,
Offset<java.lang.Double> precision)
Verifies that the actual array contains the given subsequence (possibly with other values between them).
|
SELF |
AbstractFloatArrayAssert.containsSubsequence(float[] subsequence,
Offset<java.lang.Float> precision)
Verifies that the actual array contains the given subsequence (possibly with other values between them).
|
SELF |
AbstractDoubleArrayAssert.doesNotContain(double[] values,
Offset<java.lang.Double> precision)
Verifies that the actual array does not contain the given values.
|
SELF |
AbstractDoubleArrayAssert.doesNotContain(double value,
Index index,
Offset<java.lang.Double> precision)
Verifies that the actual array does not contain the given value at the given index.
|
SELF |
AbstractFloatArrayAssert.doesNotContain(float[] values,
Offset<java.lang.Float> precision)
Verifies that the actual array does not contain the given values.
|
SELF |
AbstractFloatArrayAssert.doesNotContain(float value,
Index index,
Offset<java.lang.Float> precision)
Verifies that the actual array does not contain the given value at the given index.
|
SELF |
AbstractDoubleArrayAssert.doesNotHaveDuplicates(Offset<java.lang.Double> precision)
Verifies that the actual array does not contain duplicates.
|
SELF |
AbstractFloatArrayAssert.doesNotHaveDuplicates(Offset<java.lang.Float> precision)
Verifies that the actual array does not contain duplicates.
|
SELF |
AbstractDoubleArrayAssert.endsWith(double[] values,
Offset<java.lang.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<java.lang.Float> precision)
Verifies that the actual array ends with the given sequence of values, without any other values between them.
|
SELF |
AbstractOptionalDoubleAssert.hasValueCloseTo(java.lang.Double expectedValue,
Offset<java.lang.Double> offset)
Verifies that the actual
OptionalDouble has the value close to the argument. |
AtomicIntegerAssert |
AtomicIntegerAssert.hasValueCloseTo(int expected,
Offset<java.lang.Integer> offset)
Verifies that the actual atomic has a value close to the given one within the given offset.
If difference is equal to the offset value, assertion is considered valid. |
AtomicLongAssert |
AtomicLongAssert.hasValueCloseTo(long expected,
Offset<java.lang.Long> offset)
Verifies that the actual atomic has a value close to the given one within the given offset.
If difference is equal to the 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 |
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 |
AbstractBigDecimalAssert.isCloseTo(java.math.BigDecimal expected,
Offset<java.math.BigDecimal> 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 |
AbstractBigIntegerAssert.isCloseTo(java.math.BigInteger expected,
Offset<java.math.BigInteger> 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 |
AbstractByteAssert.isCloseTo(byte expected,
Offset<java.lang.Byte> offset)
Verifies that the actual byte is close to the given one within the given offset.
If difference is equal to offset value, assertion is considered valid. |
SELF |
AbstractByteAssert.isCloseTo(java.lang.Byte expected,
Offset<java.lang.Byte> offset)
Verifies that the actual Byte is close to the given one within the given offset.
If difference is equal to offset value, assertion is considered valid. |
SELF |
AbstractDoubleAssert.isCloseTo(double expected,
Offset<java.lang.Double> 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.isCloseTo(java.lang.Double expected,
Offset<java.lang.Double> 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 |
AbstractFloatAssert.isCloseTo(float expected,
Offset<java.lang.Float> 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 |
AbstractFloatAssert.isCloseTo(java.lang.Float expected,
Offset<java.lang.Float> 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 |
AbstractIntegerAssert.isCloseTo(java.lang.Integer expected,
Offset<java.lang.Integer> offset)
Verifies that the actual int is close to the given one within the given offset.
If difference is equal to offset value, assertion is considered valid. |
SELF |
AbstractIntegerAssert.isCloseTo(int expected,
Offset<java.lang.Integer> offset)
Verifies that the actual int is close to the given one within the given offset.
If difference is equal to offset value, assertion is considered valid. |
SELF |
AbstractLongAssert.isCloseTo(long expected,
Offset<java.lang.Long> offset)
Verifies that the actual long is close to the given one within the given offset.
If difference is equal to offset value, assertion is considered valid. |
SELF |
AbstractLongAssert.isCloseTo(java.lang.Long expected,
Offset<java.lang.Long> offset)
Verifies that the actual long is close to the given one within the given offset.
If difference is equal to offset value, assertion is considered valid. |
SELF |
AbstractShortAssert.isCloseTo(short expected,
Offset<java.lang.Short> offset)
Verifies that the actual short is close to the given one within the given offset.
If difference is equal to offset value, assertion is considered valid. |
SELF |
AbstractShortAssert.isCloseTo(java.lang.Short expected,
Offset<java.lang.Short> offset)
Verifies that the actual short is close to the given one within the given offset.
If difference is equal to offset value, assertion is considered valid. |
SELF |
FloatingPointNumberAssert.isEqualTo(ACTUAL expected,
Offset<ACTUAL> offset)
Verifies that the actual value is close to the given one by less than the given offset.
If difference is equal to offset value, assertion is considered valid. |
SELF |
AbstractDoubleAssert.isEqualTo(double expected,
Offset<java.lang.Double> offset)
Verifies that the actual value is close to the given one by less than the given offset.
If difference is equal to offset value, assertion is considered valid. |
SELF |
AbstractDoubleAssert.isEqualTo(java.lang.Double expected,
Offset<java.lang.Double> offset)
Verifies that the actual value is close to the given one by less than the given offset.
If difference is equal to offset value, assertion is considered valid. |
SELF |
AbstractFloatAssert.isEqualTo(float expected,
Offset<java.lang.Float> offset)
Verifies that the actual value is close to the given one by less than the given offset.
If difference is equal to offset value, assertion is considered valid. |
SELF |
AbstractFloatAssert.isEqualTo(java.lang.Float expected,
Offset<java.lang.Float> offset)
Verifies that the actual value is close to the given one by less than the given offset.
If difference is equal to offset value, assertion is considered valid. |
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 |
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 |
AbstractBigDecimalAssert.isNotCloseTo(java.math.BigDecimal expected,
Offset<java.math.BigDecimal> 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 |
AbstractBigIntegerAssert.isNotCloseTo(java.math.BigInteger expected,
Offset<java.math.BigInteger> 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 |
AbstractByteAssert.isNotCloseTo(byte expected,
Offset<java.lang.Byte> offset)
Verifies that the actual byte 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 |
AbstractByteAssert.isNotCloseTo(java.lang.Byte expected,
Offset<java.lang.Byte> offset)
Verifies that the actual Byte 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 |
AbstractDoubleAssert.isNotCloseTo(double expected,
Offset<java.lang.Double> 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 |
AbstractDoubleAssert.isNotCloseTo(java.lang.Double expected,
Offset<java.lang.Double> offset)
Verifies that the actual number is close to the given one by less than the given offset.
If the difference is equal to the offset value, the assertion fails. |
SELF |
AbstractFloatAssert.isNotCloseTo(float expected,
Offset<java.lang.Float> 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 |
AbstractFloatAssert.isNotCloseTo(java.lang.Float expected,
Offset<java.lang.Float> 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 |
AbstractIntegerAssert.isNotCloseTo(java.lang.Integer expected,
Offset<java.lang.Integer> offset)
Verifies that the actual int 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 |
AbstractIntegerAssert.isNotCloseTo(int expected,
Offset<java.lang.Integer> offset)
Verifies that the actual int 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 |
AbstractLongAssert.isNotCloseTo(long expected,
Offset<java.lang.Long> offset)
Verifies that the actual long 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 |
AbstractLongAssert.isNotCloseTo(java.lang.Long expected,
Offset<java.lang.Long> offset)
Verifies that the actual long 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 |
AbstractShortAssert.isNotCloseTo(short expected,
Offset<java.lang.Short> offset)
Verifies that the actual short 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 |
AbstractShortAssert.isNotCloseTo(java.lang.Short expected,
Offset<java.lang.Short> offset)
Verifies that the actual short 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 |
AbstractDoubleArrayAssert.startsWith(double[] values,
Offset<java.lang.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<java.lang.Float> precision)
Verifies that the actual array starts with the given sequence of values, without any other values between them.
|
Modifier and Type | Method and Description |
---|---|
static <T extends java.lang.Number> |
Offset.offset(T value)
Creates a new
Offset . |
Modifier and Type | Method and Description |
---|---|
static <T extends java.lang.Number> |
ShouldBeEqualWithinOffset.shouldBeEqual(T actual,
T expected,
Offset<T> offset,
T difference)
Creates a new
. |
static OptionalDoubleShouldHaveValueCloseTo |
OptionalDoubleShouldHaveValueCloseTo.shouldHaveValueCloseTo(java.util.OptionalDouble optional,
double expectedValue,
Offset<java.lang.Double> offset,
double difference)
Indicates that the provided
OptionalDouble does not have the provided argument. |
static <T extends java.lang.Number> |
ShouldNotBeEqualWithinOffset.shouldNotBeEqual(T actual,
T expected,
Offset<T> offset,
T difference)
Creates a new
. |
Constructor and Description |
---|
OptionalDoubleShouldHaveValueCloseTo(java.util.OptionalDouble actual,
double expected,
Offset<java.lang.Double> offset,
double difference) |
ShouldBeEqualWithinOffset(java.lang.Number actual,
java.lang.Number expected,
Offset<T> offset,
java.lang.Number difference) |
ShouldNotBeEqualWithinOffset(java.lang.Number actual,
java.lang.Number expected,
Offset<T> offset,
java.lang.Number difference) |
Modifier and Type | Method and Description |
---|---|
void |
RealNumbers.assertEqual(AssertionInfo info,
NUMBER actual,
NUMBER expected,
Offset<NUMBER> offset)
Verifies that two real numbers are equal within a positive offset.
It does not rely on the custom comparisonStrategy (if one is set) because using an offset is already a specific comparison strategy. |
void |
Numbers.assertIsCloseTo(AssertionInfo info,
NUMBER actual,
NUMBER expected,
Offset<NUMBER> offset)
Asserts that the actual value is close to the offset.
|
void |
Numbers.assertIsNotCloseTo(AssertionInfo info,
NUMBER actual,
NUMBER expected,
Offset<NUMBER> offset)
Asserts that the actual value is not close to the offset.
|
(package private) static void |
CommonValidations.checkOffsetIsNotNull(Offset<?> offset) |