Uses of Class
org.assertj.core.data.Offset

Packages that use Offset

Package	Description
org.assertj.core.api
org.assertj.core.data
org.assertj.core.error

Uses of Offset in org.assertj.core.api

Methods in org.assertj.core.api that return Offset

Modifier and Type	Method	Description
static Offset<Byte>	Assertions.byLessThan(Byte value)	Assertions entry point for Byte Offset 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<Float>	Assertions.byLessThan(Float value)	Alias for Assertions.offset(Float) to use with isCloseTo assertions.
static Offset<Integer>	Assertions.byLessThan(Integer value)	Assertions entry point for Long Offset to use with strict isCloseTo assertions.
static Offset<Long>	Assertions.byLessThan(Long value)	Assertions entry point for Long Offset to use with strict isCloseTo assertions.
static Offset<Short>	Assertions.byLessThan(Short value)	Assertions entry point for Short 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<BigInteger>	Assertions.byLessThan(BigInteger value)	Assertions entry point for BigInteger Offset to use with isCloseTo assertions.
static Offset<Byte>	BDDAssertions.byLessThan(Byte value)	Assertions entry point for Byte Offset to use with isCloseTo assertions.
static Offset<Double>	BDDAssertions.byLessThan(Double value)	Build a strict Offset to use with AbstractDoubleAssert.isCloseTo(double, Offset) and AbstractDoubleAssert.isNotCloseTo(double, Offset) assertions.
static Offset<Float>	BDDAssertions.byLessThan(Float value)	Alias for Assertions.offset(Float) to use with isCloseTo assertions.
static Offset<Integer>	BDDAssertions.byLessThan(Integer value)	Assertions entry point for Long Offset to use with strict isCloseTo assertions.
static Offset<Long>	BDDAssertions.byLessThan(Long value)	Assertions entry point for Long Offset to use with strict isCloseTo assertions.
static Offset<Short>	BDDAssertions.byLessThan(Short value)	Assertions entry point for Short Offset to use with isCloseTo assertions.
static Offset<BigDecimal>	BDDAssertions.byLessThan(BigDecimal value)	Assertions entry point for BigDecimal Offset to use with isCloseTo assertions.
static Offset<BigInteger>	BDDAssertions.byLessThan(BigInteger value)	Assertions entry point for BigInteger Offset to use with isCloseTo assertions.
static Offset<Byte>	Java6Assertions.byLessThan(Byte value)	Deprecated. Assertions entry point for Byte Offset to use with isCloseTo assertions.
static Offset<Double>	Java6Assertions.byLessThan(Double value)	Deprecated. Alias for Java6Assertions.offset(Double) to use with isCloseTo assertions.
static Offset<Float>	Java6Assertions.byLessThan(Float value)	Deprecated. Alias for Java6Assertions.offset(Float) to use with isCloseTo assertions.
static Offset<Integer>	Java6Assertions.byLessThan(Integer value)	Deprecated. Assertions entry point for Integer Offset to use with isCloseTo assertions.
static Offset<Long>	Java6Assertions.byLessThan(Long value)	Deprecated. Assertions entry point for Long Offset to use with isCloseTo assertions.
static Offset<Short>	Java6Assertions.byLessThan(Short value)	Deprecated. Assertions entry point for Short Offset to use with isCloseTo assertions.
static Offset<BigDecimal>	Java6Assertions.byLessThan(BigDecimal value)	Deprecated. Assertions entry point for BigDecimal Offset to use with isCloseTo assertions.
static Offset<BigInteger>	Java6Assertions.byLessThan(BigInteger value)	Deprecated. 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.
default Offset<Double>	WithAssertions.byLessThan(Double value)	Alias for WithAssertions.offset(Double) to use with isCloseTo assertions.
default Offset<Float>	WithAssertions.byLessThan(Float value)	Alias for WithAssertions.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.
default Offset<Long>	WithAssertions.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.
default Offset<BigDecimal>	WithAssertions.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<Double>	Assertions.offset(Double value)	Assertions entry point for double Offset.
static Offset<Float>	Assertions.offset(Float value)	Assertions entry point for float Offset.
static Offset<Double>	AssertionsForClassTypes.offset(Double value)	Assertions entry point for double Offset.
static Offset<Float>	AssertionsForClassTypes.offset(Float value)	Assertions entry point for float Offset.
static Offset<Double>	Java6Assertions.offset(Double value)	Deprecated. Assertions entry point for double Offset.
static Offset<Float>	Java6Assertions.offset(Float value)	Deprecated. Assertions entry point for float Offset.
default Offset<Double>	WithAssertions.offset(Double value)	Assertions entry point for double Offset.
default Offset<Float>	WithAssertions.offset(Float value)	Assertions entry point for float Offset.
static Offset<Byte>	Assertions.within(Byte value)	Assertions entry point for Byte Offset to use with isCloseTo assertions.
static Offset<Double>	Assertions.within(Double value)	Alias for Assertions.offset(Double) to use with isCloseTo assertions.
static Offset<Float>	Assertions.within(Float value)	Alias for Assertions.offset(Float) 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<Long>	Assertions.within(Long value)	Assertions entry point for Long 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<BigDecimal>	Assertions.within(BigDecimal value)	Assertions entry point for BigDecimal 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<Byte>	AssertionsForClassTypes.within(Byte value)	Assertions entry point for Byte Offset to use with isCloseTo assertions.
static Offset<Double>	AssertionsForClassTypes.within(Double value)	Alias for AssertionsForClassTypes.offset(Double) to use with isCloseTo assertions.
static Offset<Float>	AssertionsForClassTypes.within(Float value)	Alias for AssertionsForClassTypes.offset(Float) 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<Long>	AssertionsForClassTypes.within(Long value)	Assertions entry point for Long 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<BigDecimal>	AssertionsForClassTypes.within(BigDecimal value)	Assertions entry point for BigDecimal Offset to use with isCloseTo assertions.
static Offset<Byte>	BDDAssertions.within(Byte value)	Assertions entry point for Byte Offset to use with isCloseTo assertions.
static Offset<Double>	BDDAssertions.within(Double value)	Builds an Offset to use with isCloseTo assertions.
static Offset<Float>	BDDAssertions.within(Float value)	Builds an Offset to use with isCloseTo assertions.
static Offset<Integer>	BDDAssertions.within(Integer value)	Assertions entry point for Integer Offset to use with isCloseTo assertions.
static Offset<Long>	BDDAssertions.within(Long value)	Assertions entry point for Long Offset to use with isCloseTo assertions.
static Offset<Short>	BDDAssertions.within(Short value)	Assertions entry point for Short Offset to use with isCloseTo assertions.
static Offset<BigDecimal>	BDDAssertions.within(BigDecimal value)	Assertions entry point for BigDecimal Offset to use with isCloseTo assertions.
static Offset<BigInteger>	BDDAssertions.within(BigInteger value)	Assertions entry point for BigInteger Offset to use with isCloseTo assertions.
static Offset<Byte>	Java6Assertions.within(Byte value)	Deprecated. Assertions entry point for Byte Offset to use with isCloseTo assertions.
static Offset<Double>	Java6Assertions.within(Double value)	Deprecated. Alias for Java6Assertions.offset(Double) to use with isCloseTo assertions.
static Offset<Float>	Java6Assertions.within(Float value)	Deprecated. Alias for Java6Assertions.offset(Float) to use with isCloseTo assertions.
static Offset<Integer>	Java6Assertions.within(Integer value)	Deprecated. Assertions entry point for Integer Offset to use with isCloseTo assertions.
static Offset<Long>	Java6Assertions.within(Long value)	Deprecated. Assertions entry point for Long Offset to use with isCloseTo assertions.
static Offset<Short>	Java6Assertions.within(Short value)	Deprecated. Assertions entry point for Short Offset to use with isCloseTo assertions.
static Offset<BigDecimal>	Java6Assertions.within(BigDecimal value)	Deprecated. Assertions entry point for BigDecimal Offset to use with isCloseTo assertions.
static Offset<BigInteger>	Java6Assertions.within(BigInteger value)	Deprecated. 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.
default Offset<Double>	WithAssertions.within(Double value)	Alias for WithAssertions.offset(Double) to use with isCloseTo assertions.
default Offset<Float>	WithAssertions.within(Float value)	Alias for WithAssertions.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.
default Offset<Long>	WithAssertions.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.
default Offset<BigDecimal>	WithAssertions.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<Double>	Assertions.withPrecision(Double value)	Alias for Assertions.offset(Double) to use with real number assertions.
static Offset<Float>	Assertions.withPrecision(Float value)	Alias for Assertions.offset(Float) to use with real number assertions.
static Offset<Double>	BDDAssertions.withPrecision(Double value)	Builds an Offset to use with real number assertions.
static Offset<Float>	BDDAssertions.withPrecision(Float value)	Builds an Offset to use with real number assertions.
default Offset<Double>	WithAssertions.withPrecision(Double value)	Assertions entry point for double Offset.
default Offset<Float>	WithAssertions.withPrecision(Float value)	Assertions entry point for float Offset.

Methods in org.assertj.core.api with parameters of type Offset

Modifier and Type	Method	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	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.

Uses of Offset in org.assertj.core.data

Methods in org.assertj.core.data that return Offset

Modifier and Type	Method	Description
static <T extends Number> Offset<T>	Offset.offset(T value)	Creates a new Offset that let isCloseTo assertions pass when |actual-expected| <= offset value.
static <T extends Number> Offset<T>	Offset.strictOffset(T value)	Creates a new strict Offset that let isCloseTo assertion pass when |actual-expected| < offset value.

Uses of Offset in org.assertj.core.error

Methods in org.assertj.core.error with parameters of type Offset

Modifier and Type	Method	Description
static <T extends Number> ErrorMessageFactory	ShouldBeEqualWithinOffset.shouldBeEqual(T actual, T expected, Offset<T> offset, T difference)	Creates a new ShouldBeEqualWithinOffset.
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> ErrorMessageFactory	ShouldNotBeEqualWithinOffset.shouldNotBeEqual(T actual, T expected, Offset<T> offset, T difference)	Creates a new ShouldNotBeEqualWithinOffset.