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<Double> |
Java6Assertions.offset(Double value)
Assertions entry point for double
Offset . |
static Offset<Double> |
Assertions.offset(Double value)
Assertions entry point for double
Offset . |
static Offset<Float> |
Java6Assertions.offset(Float value)
Assertions entry point for float
Offset . |
static Offset<Float> |
Assertions.offset(Float value)
Assertions entry point for float
Offset . |
static Offset<BigDecimal> |
Java6Assertions.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<Byte> |
Java6Assertions.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<Double> |
Java6Assertions.within(Double value)
Alias for
Java6Assertions.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<Float> |
Java6Assertions.within(Float value)
Alias for
Java6Assertions.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<Integer> |
Java6Assertions.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<Long> |
Java6Assertions.within(Long value)
Assertions entry point for Long
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> |
Java6Assertions.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<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. |
Modifier and Type | Method and Description |
---|---|
S |
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) . |
S |
AbstractDoubleArrayAssert.contains(double value,
Index index,
Offset<Double> precision)
Verifies that the actual array contains the given value at the given index.
|
S |
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) . |
S |
AbstractFloatArrayAssert.contains(float value,
Index index,
Offset<Float> precision)
Verifies that the actual array contains the given value at the given index.
|
S |
AbstractDoubleArrayAssert.containsExactly(double[] values,
Offset<Double> precision)
Verifies that the actual group contains only the given values and nothing else, in order.
|
S |
AbstractFloatArrayAssert.containsExactly(float[] values,
Offset<Float> precision)
Verifies that the actual group contains only the given values and nothing else, in order.
|
S |
AbstractDoubleArrayAssert.containsOnly(double[] values,
Offset<Double> precision)
Verifies that the actual array contains only the given values and nothing else, in any order.
|
S |
AbstractFloatArrayAssert.containsOnly(float[] values,
Offset<Float> precision)
Verifies that the actual array contains only the given values and nothing else, in any order.
|
S |
AbstractDoubleArrayAssert.containsOnlyOnce(double[] values,
Offset<Double> precision)
Verifies that the actual array contains the given values only once.
|
S |
AbstractFloatArrayAssert.containsOnlyOnce(float[] values,
Offset<Float> precision)
Verifies that the actual array contains the given values only once.
|
S |
AbstractDoubleArrayAssert.containsSequence(double[] sequence,
Offset<Double> precision)
Verifies that the actual array contains the given sequence, without any other values between them.
|
S |
AbstractFloatArrayAssert.containsSequence(float[] sequence,
Offset<Float> precision)
Verifies that the actual array contains the given sequence, without any other values between them.
|
S |
AbstractDoubleArrayAssert.containsSubsequence(double[] subsequence,
Offset<Double> precision)
Verifies that the actual array contains the given subsequence (possibly with other values between them).
|
S |
AbstractFloatArrayAssert.containsSubsequence(float[] subsequence,
Offset<Float> precision)
Verifies that the actual array contains the given subsequence (possibly with other values between them).
|
S |
AbstractDoubleArrayAssert.doesNotContain(double[] values,
Offset<Double> precision)
Verifies that the actual array does not contain the given values.
|
S |
AbstractDoubleArrayAssert.doesNotContain(double value,
Index index,
Offset<Double> precision)
Verifies that the actual array does not contain the given value at the given index.
|
S |
AbstractFloatArrayAssert.doesNotContain(float[] values,
Offset<Float> precision)
Verifies that the actual array does not contain the given values.
|
S |
AbstractFloatArrayAssert.doesNotContain(float value,
Index index,
Offset<Float> precision)
Verifies that the actual array does not contain the given value at the given index.
|
S |
AbstractDoubleArrayAssert.doesNotHaveDuplicates(Offset<Double> precision)
Verifies that the actual array does not contain duplicates.
|
S |
AbstractFloatArrayAssert.doesNotHaveDuplicates(Offset<Float> precision)
Verifies that the actual array does not contain duplicates.
|
S |
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.
|
S |
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.
|
S |
FloatingPointNumberAssert.isCloseTo(A expected,
Offset<A> 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. |
S |
NumberAssert.isCloseTo(A expected,
Offset<A> 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. |
S |
AbstractBigDecimalAssert.isCloseTo(BigDecimal other,
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. |
S |
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. |
S |
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. |
S |
AbstractDoubleAssert.isCloseTo(double other,
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. |
S |
AbstractDoubleAssert.isCloseTo(Double other,
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. |
S |
AbstractFloatAssert.isCloseTo(float other,
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. |
S |
AbstractFloatAssert.isCloseTo(Float other,
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. |
S |
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. |
S |
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. |
S |
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. |
S |
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. |
S |
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. |
S |
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. |
S |
FloatingPointNumberAssert.isEqualTo(A expected,
Offset<A> 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. |
S |
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. |
S |
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. |
S |
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. |
S |
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. |
S |
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.
|
S |
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)
Creates a new
Offset . |
Modifier and Type | Method and Description |
---|---|
static <T extends Number> |
ShouldBeEqualWithinOffset.shouldBeEqual(T actual,
T expected,
Offset<T> offset,
T difference)
Creates a new
. |
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.
|
Copyright © 2013–2016 AssertJ. All rights reserved.