Package | Description |
---|---|
org.assertj.core.api | |
org.assertj.core.data | |
org.assertj.core.error | |
org.assertj.core.internal |
Modifier and Type | Method and Description |
---|---|
default Offset<BigDecimal> |
WithAssertions.byLessThan(BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
static Offset<BigDecimal> |
Assertions.byLessThan(BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
static Offset<BigDecimal> |
Java6Assertions.byLessThan(BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
default Offset<BigInteger> |
WithAssertions.byLessThan(BigInteger value)
Assertions entry point for BigInteger
Offset to use with isCloseTo assertions. |
static Offset<BigInteger> |
Assertions.byLessThan(BigInteger value)
Assertions entry point for BigInteger
Offset to use with isCloseTo assertions. |
static Offset<BigInteger> |
Java6Assertions.byLessThan(BigInteger value)
Assertions entry point for BigInteger
Offset to use with isCloseTo assertions. |
default Offset<Byte> |
WithAssertions.byLessThan(Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
static Offset<Byte> |
Assertions.byLessThan(Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
static Offset<Byte> |
Java6Assertions.byLessThan(Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
default Offset<Double> |
WithAssertions.byLessThan(Double value)
Alias for
WithAssertions.offset(Double) to use with isCloseTo assertions. |
static Offset<Double> |
Assertions.byLessThan(Double value)
Build a
strict Offset to use with AbstractDoubleAssert.isCloseTo(double, Offset) and AbstractDoubleAssert.isNotCloseTo(double, Offset) assertions. |
static Offset<Double> |
Java6Assertions.byLessThan(Double value)
Alias for
Java6Assertions.offset(Double) to use with isCloseTo assertions. |
default Offset<Float> |
WithAssertions.byLessThan(Float value)
Alias for
WithAssertions.offset(Float) to use with isCloseTo assertions. |
static Offset<Float> |
Assertions.byLessThan(Float value)
Alias for
Assertions.offset(Float) to use with isCloseTo assertions. |
static Offset<Float> |
Java6Assertions.byLessThan(Float value)
Alias for
Java6Assertions.offset(Float) to use with isCloseTo assertions. |
default Offset<Integer> |
WithAssertions.byLessThan(Integer value)
Assertions entry point for Integer
Offset to use with isCloseTo assertions. |
static Offset<Integer> |
Assertions.byLessThan(Integer value)
|
static Offset<Integer> |
Java6Assertions.byLessThan(Integer value)
Assertions entry point for Integer
Offset to use with isCloseTo assertions. |
default Offset<Long> |
WithAssertions.byLessThan(Long value)
Assertions entry point for Long
Offset to use with isCloseTo assertions. |
static Offset<Long> |
Assertions.byLessThan(Long value)
|
static Offset<Long> |
Java6Assertions.byLessThan(Long value)
Assertions entry point for Long
Offset to use with isCloseTo assertions. |
default Offset<Short> |
WithAssertions.byLessThan(Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
static Offset<Short> |
Assertions.byLessThan(Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
static Offset<Short> |
Java6Assertions.byLessThan(Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
default Offset<Double> |
WithAssertions.offset(Double value)
Assertions entry point for double
Offset . |
static Offset<Double> |
Assertions.offset(Double value)
Assertions entry point for double
Offset . |
static Offset<Double> |
AssertionsForClassTypes.offset(Double value)
Assertions entry point for double
Offset . |
static Offset<Double> |
Java6Assertions.offset(Double value)
Assertions entry point for double
Offset . |
default Offset<Float> |
WithAssertions.offset(Float value)
Assertions entry point for float
Offset . |
static Offset<Float> |
Assertions.offset(Float value)
Assertions entry point for float
Offset . |
static Offset<Float> |
AssertionsForClassTypes.offset(Float value)
Assertions entry point for float
Offset . |
static Offset<Float> |
Java6Assertions.offset(Float value)
Assertions entry point for float
Offset . |
default Offset<BigDecimal> |
WithAssertions.within(BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
static Offset<BigDecimal> |
Assertions.within(BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
static Offset<BigDecimal> |
AssertionsForClassTypes.within(BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
static Offset<BigDecimal> |
Java6Assertions.within(BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
default Offset<BigInteger> |
WithAssertions.within(BigInteger value)
Assertions entry point for BigInteger
Offset to use with isCloseTo assertions. |
static Offset<BigInteger> |
Assertions.within(BigInteger value)
Assertions entry point for BigInteger
Offset to use with isCloseTo assertions. |
static Offset<BigInteger> |
Java6Assertions.within(BigInteger value)
Assertions entry point for BigInteger
Offset to use with isCloseTo assertions. |
default Offset<Byte> |
WithAssertions.within(Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
static Offset<Byte> |
Assertions.within(Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
static Offset<Byte> |
AssertionsForClassTypes.within(Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
static Offset<Byte> |
Java6Assertions.within(Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
default Offset<Double> |
WithAssertions.within(Double value)
Alias for
WithAssertions.offset(Double) to use with isCloseTo assertions. |
static Offset<Double> |
Assertions.within(Double value)
Alias for
Assertions.offset(Double) to use with isCloseTo assertions. |
static Offset<Double> |
AssertionsForClassTypes.within(Double value)
Alias for
AssertionsForClassTypes.offset(Double) to use with isCloseTo assertions. |
static Offset<Double> |
Java6Assertions.within(Double value)
Alias for
Java6Assertions.offset(Double) to use with isCloseTo assertions. |
default Offset<Float> |
WithAssertions.within(Float value)
Alias for
WithAssertions.offset(Float) to use with isCloseTo assertions. |
static Offset<Float> |
Assertions.within(Float value)
Alias for
Assertions.offset(Float) to use with isCloseTo assertions. |
static Offset<Float> |
AssertionsForClassTypes.within(Float value)
Alias for
AssertionsForClassTypes.offset(Float) to use with isCloseTo assertions. |
static Offset<Float> |
Java6Assertions.within(Float value)
Alias for
Java6Assertions.offset(Float) to use with isCloseTo assertions. |
default Offset<Integer> |
WithAssertions.within(Integer value)
Assertions entry point for Integer
Offset to use with isCloseTo assertions. |
static Offset<Integer> |
Assertions.within(Integer value)
Assertions entry point for Integer
Offset to use with isCloseTo assertions. |
static Offset<Integer> |
AssertionsForClassTypes.within(Integer value)
Assertions entry point for Integer
Offset to use with isCloseTo assertions. |
static Offset<Integer> |
Java6Assertions.within(Integer value)
Assertions entry point for Integer
Offset to use with isCloseTo assertions. |
default Offset<Long> |
WithAssertions.within(Long value)
Assertions entry point for Long
Offset to use with isCloseTo assertions. |
static Offset<Long> |
Assertions.within(Long value)
|
static Offset<Long> |
AssertionsForClassTypes.within(Long value)
Assertions entry point for Long
Offset to use with isCloseTo assertions. |
static Offset<Long> |
Java6Assertions.within(Long value)
Assertions entry point for Long
Offset to use with isCloseTo assertions. |
default Offset<Short> |
WithAssertions.within(Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
static Offset<Short> |
Assertions.within(Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
static Offset<Short> |
AssertionsForClassTypes.within(Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
static Offset<Short> |
Java6Assertions.within(Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
default Offset<Double> |
WithAssertions.withPrecision(Double value)
Assertions entry point for double
Offset . |
static Offset<Double> |
Assertions.withPrecision(Double value)
Alias for
Assertions.offset(Double) to use with real number assertions. |
default Offset<Float> |
WithAssertions.withPrecision(Float value)
Assertions entry point for float
Offset . |
static Offset<Float> |
Assertions.withPrecision(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<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 |
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 |
AbstractDoubleArrayAssert.containsExactly(double[] values,
Offset<Double> 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 given values 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 |
AbstractFloatArrayAssert.containsOnly(float[] values,
Offset<Float> precision)
Verifies that the actual array contains only the given values 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 |
AbstractFloatArrayAssert.containsOnlyOnce(float[] values,
Offset<Float> precision)
Verifies that the actual array contains the given values 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 |
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 |
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 |
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 |
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 |
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 |
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(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(Integer expected,
Offset<Integer> 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 |
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.isEqualTo(ACTUAL expected,
Offset<ACTUAL> 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 |
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 |
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(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(Integer 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(int expected,
Offset<Integer> 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 |
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 |
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.
|
Modifier and Type | Method and Description |
---|---|
static <T extends Number> |
Offset.offset(T value)
|
static <T extends Number> |
Offset.strictOffset(T value)
Creates a new strict
Offset that let isCloseTo assertion pass when |actual-expected| < offset value . |
Modifier and Type | Method and Description |
---|---|
static <T extends Number> |
ShouldBeEqualWithinOffset.shouldBeEqual(T actual,
T expected,
Offset<T> offset,
T difference)
Creates a new
. |
static OptionalDoubleShouldHaveValueCloseToOffset |
OptionalDoubleShouldHaveValueCloseToOffset.shouldHaveValueCloseToOffset(OptionalDouble optional,
double expectedValue,
Offset<Double> offset,
double difference)
Indicates that the provided
OptionalDouble does not have the provided argument. |
static <T extends Number> |
ShouldNotBeEqualWithinOffset.shouldNotBeEqual(T actual,
T expected,
Offset<T> offset,
T difference)
Creates a new
. |
Modifier and Type | Method and Description |
---|---|
void |
Numbers.assertIsCloseTo(AssertionInfo info,
NUMBER actual,
NUMBER expected,
Offset<NUMBER> offset)
Asserts that the actual value is close to the expected one by less than the given offset.
|
void |
Numbers.assertIsNotCloseTo(AssertionInfo info,
NUMBER actual,
NUMBER expected,
Offset<NUMBER> offset)
Asserts that the actual value is not close to the expected one by less than the given offset.
|
Copyright © 2014–2019 AssertJ. All rights reserved.