hope.kola.contract.assertj.bridge.DoubleAssert 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.AbstractDoubleAssert} */
public class DoubleAssert extends AssertThat {
  @Override
  public PrimitiveType primitiveType() {
    return PrimitiveType.DOUBLE;
  }

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

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

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

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

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

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

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

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

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

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

  /** {@link org.assertj.core.api.AbstractDoubleAssert#isCloseTo} */
  public DoubleAssert isCloseTo(Double expected, Offset offset) {
    segment("isCloseTo")
        .argument(DynamicProperty.newDouble(expected))
        .argument(DynamicProperty.newOffset(offset));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractDoubleAssert#isNotCloseTo} */
  public DoubleAssert isNotCloseTo(Double expected, Offset offset) {
    segment("isNotCloseTo")
        .argument(DynamicProperty.newDouble(expected))
        .argument(DynamicProperty.newOffset(offset));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractDoubleAssert#isEqualTo} */
  public DoubleAssert isEqualTo(Double expected) {
    segment("isEqualTo").argument(DynamicProperty.newDouble(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractDoubleAssert#isEqualTo} */
  public DoubleAssert isEqualTo(Double expected, Offset offset) {
    segment("isEqualTo")
        .argument(DynamicProperty.newDouble(expected))
        .argument(DynamicProperty.newOffset(offset));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractDoubleAssert#isNotEqualTo} */
  public DoubleAssert isNotEqualTo(Double other) {
    segment("isNotEqualTo").argument(DynamicProperty.newDouble(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractDoubleAssert#isLessThan} */
  public DoubleAssert isLessThan(Double other) {
    segment("isLessThan").argument(DynamicProperty.newDouble(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractDoubleAssert#isLessThanOrEqualTo} */
  public DoubleAssert isLessThanOrEqualTo(Double other) {
    segment("isLessThanOrEqualTo").argument(DynamicProperty.newDouble(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractDoubleAssert#isGreaterThan} */
  public DoubleAssert isGreaterThan(Double other) {
    segment("isGreaterThan").argument(DynamicProperty.newDouble(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractDoubleAssert#isGreaterThanOrEqualTo} */
  public DoubleAssert isGreaterThanOrEqualTo(Double other) {
    segment("isGreaterThanOrEqualTo").argument(DynamicProperty.newDouble(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractDoubleAssert#isBetween} */
  public DoubleAssert isBetween(Double start, Double end) {
    segment("isBetween")
        .argument(DynamicProperty.newDouble(start))
        .argument(DynamicProperty.newDouble(end));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractDoubleAssert#isStrictlyBetween} */
  public DoubleAssert isStrictlyBetween(Double start, Double end) {
    segment("isStrictlyBetween")
        .argument(DynamicProperty.newDouble(start))
        .argument(DynamicProperty.newDouble(end));
    return this;
  }

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

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

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

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