hope.kola.contract.assertj.bridge.FloatAssert Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of it-kola-contract Show documentation
null
There is a newer version: 1.1.2-RELEASE
package hope.kola.contract.assertj.bridge;

import com.squareup.javapoet.ClassName;
import hope.kola.contract.assertj.model.DynamicProperty;
import hope.kola.contract.assertj.model.PrimitiveType;
import org.assertj.core.data.Offset;

/** {@link org.assertj.core.api.AbstractFloatAssert} */
public class FloatAssert extends AssertThat {
  @Override
  public PrimitiveType primitiveType() {
    return PrimitiveType.FLOAT;
  }

  @Override
  public ClassName assertJClass() {
    return ClassName.get("org.assertj.core.api", "AbstractFloatAssert");
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isNaN} */
  public FloatAssert isNaN() {
    segment("isNaN");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isNotNaN} */
  public FloatAssert isNotNaN() {
    segment("isNotNaN");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isZero} */
  public FloatAssert isZero() {
    segment("isZero");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isNotZero} */
  public FloatAssert isNotZero() {
    segment("isNotZero");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isOne} */
  public FloatAssert isOne() {
    segment("isOne");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isPositive} */
  public FloatAssert isPositive() {
    segment("isPositive");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isNegative} */
  public FloatAssert isNegative() {
    segment("isNegative");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isNotNegative} */
  public FloatAssert isNotNegative() {
    segment("isNotNegative");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isNotPositive} */
  public FloatAssert isNotPositive() {
    segment("isNotPositive");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isEqualTo} */
  public FloatAssert isEqualTo(Float expected) {
    segment("isEqualTo").argument(DynamicProperty.newFloat(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isCloseTo} */
  public FloatAssert isCloseTo(Float expected, Offset offset) {
    segment("isCloseTo")
        .argument(DynamicProperty.newFloat(expected))
        .argument(DynamicProperty.newOffset(offset));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isNotCloseTo} */
  public FloatAssert isNotCloseTo(Float expected, Offset offset) {
    segment("isNotCloseTo")
        .argument(DynamicProperty.newFloat(expected))
        .argument(DynamicProperty.newOffset(offset));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isEqualTo} */
  public FloatAssert isEqualTo(Float expected, Offset offset) {
    segment("isEqualTo")
        .argument(DynamicProperty.newFloat(expected))
        .argument(DynamicProperty.newOffset(offset));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isNotEqualTo} */
  public FloatAssert isNotEqualTo(Float other) {
    segment("isNotEqualTo").argument(DynamicProperty.newFloat(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isLessThan} */
  public FloatAssert isLessThan(Float other) {
    segment("isLessThan").argument(DynamicProperty.newFloat(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isLessThanOrEqualTo} */
  public FloatAssert isLessThanOrEqualTo(Float other) {
    segment("isLessThanOrEqualTo").argument(DynamicProperty.newFloat(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isGreaterThan} */
  public FloatAssert isGreaterThan(Float other) {
    segment("isGreaterThan").argument(DynamicProperty.newFloat(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isGreaterThanOrEqualTo} */
  public FloatAssert isGreaterThanOrEqualTo(Float other) {
    segment("isGreaterThanOrEqualTo").argument(DynamicProperty.newFloat(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isBetween} */
  public FloatAssert isBetween(Float start, Float end) {
    segment("isBetween")
        .argument(DynamicProperty.newFloat(start))
        .argument(DynamicProperty.newFloat(end));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isStrictlyBetween} */
  public FloatAssert isStrictlyBetween(Float start, Float end) {
    segment("isStrictlyBetween")
        .argument(DynamicProperty.newFloat(start))
        .argument(DynamicProperty.newFloat(end));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isFinite} */
  public FloatAssert isFinite() {
    segment("isFinite");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isNotFinite} */
  public FloatAssert isNotFinite() {
    segment("isNotFinite");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isInfinite} */
  public FloatAssert isInfinite() {
    segment("isInfinite");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractFloatAssert#isNotInfinite} */
  public FloatAssert isNotInfinite() {
    segment("isNotInfinite");
    return this;
  }
}