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
org.assertj.core.internal

Uses of Offset in org.assertj.core.api

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

Modifier and Type	Method and Description
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.
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.
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.
static Offset<Double>	Assertions.byLessThan(Double value) Alias for Assertions.offset(Double) to use with isCloseTo assertions.
static Offset<Double>	Java6Assertions.byLessThan(Double value) Alias for Java6Assertions.offset(Double) 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.
static Offset<Integer>	Assertions.byLessThan(Integer value) Assertions entry point for Integer Offset to use with isCloseTo assertions.
static Offset<Integer>	Java6Assertions.byLessThan(Integer value) Assertions entry point for Integer Offset to use with isCloseTo assertions.
static Offset<Long>	Assertions.byLessThan(Long value) Assertions entry point for Long Offset to use with isCloseTo assertions.
static Offset<Long>	Java6Assertions.byLessThan(Long value) Assertions entry point for Long 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.
static Offset<Double>	Assertions.offset(Double value) Assertions entry point for double Offset.
static Offset<Double>	Java6Assertions.offset(Double value) Assertions entry point for double Offset.
static Offset<Float>	Assertions.offset(Float value) Assertions entry point for float Offset.
static Offset<Float>	Java6Assertions.offset(Float value) Assertions entry point for float Offset.
static Offset<BigDecimal>	Assertions.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.
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.
static Offset<Byte>	Assertions.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.
static Offset<Double>	Assertions.within(Double value) Alias for Assertions.offset(Double) to use with isCloseTo assertions.
static Offset<Double>	Java6Assertions.within(Double value) Alias for Java6Assertions.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<Float>	Java6Assertions.within(Float value) Alias for Java6Assertions.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<Integer>	Java6Assertions.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<Long>	Java6Assertions.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<Short>	Java6Assertions.within(Short value) Assertions entry point for Short 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.

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

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.
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. If difference is equal to the offset value, assertion is considered valid.
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. 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(BigDecimal expected, Offset<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(BigInteger expected, Offset<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<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(Byte expected, Offset<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<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(Double expected, Offset<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<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(Float expected, Offset<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(Integer expected, Offset<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<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<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(Long expected, Offset<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<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(Short expected, Offset<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<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(Double expected, Offset<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<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(Float expected, Offset<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(BigDecimal expected, Offset<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(BigInteger expected, Offset<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<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(Byte expected, Offset<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<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(Double expected, Offset<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<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(Float expected, Offset<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(Integer expected, Offset<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<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<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(Long expected, Offset<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<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(Short expected, Offset<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<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.

Uses of Offset in org.assertj.core.data

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

Modifier and Type	Method and Description
static <T extends Number> Offset<T>	Offset.offset(T value) Creates a new Offset.

Uses of Offset in org.assertj.core.error

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

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

Uses of Offset in org.assertj.core.internal

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

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.