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

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

  /** {@link org.assertj.core.api.AbstractIntegerAssert#isEqualTo} */
  public IntegerAssert isEqualTo(Integer expected) {
    segment("isEqualTo").argument(DynamicProperty.newInteger(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractIntegerAssert#canBeCastToInt} */
  public IntegerAssert canBeCastToInt(Long expected) {
    segment("canBeCastToInt").argument(DynamicProperty.newLong(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractIntegerAssert#isNotEqualTo} */
  public IntegerAssert isNotEqualTo(Integer other) {
    segment("isNotEqualTo").argument(DynamicProperty.newInteger(other));
    return this;
  }

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

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

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

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

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

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

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

  /** {@link org.assertj.core.api.AbstractIntegerAssert#isEven} */
  public IntegerAssert isEven() {
    segment("isEven");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractIntegerAssert#isOdd} */
  public IntegerAssert isOdd() {
    segment("isOdd");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractIntegerAssert#isLessThan} */
  public IntegerAssert isLessThan(Integer other) {
    segment("isLessThan").argument(DynamicProperty.newInteger(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractIntegerAssert#isLessThanOrEqualTo} */
  public IntegerAssert isLessThanOrEqualTo(Integer other) {
    segment("isLessThanOrEqualTo").argument(DynamicProperty.newInteger(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractIntegerAssert#isGreaterThan} */
  public IntegerAssert isGreaterThan(Integer other) {
    segment("isGreaterThan").argument(DynamicProperty.newInteger(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractIntegerAssert#isGreaterThanOrEqualTo} */
  public IntegerAssert isGreaterThanOrEqualTo(Integer other) {
    segment("isGreaterThanOrEqualTo").argument(DynamicProperty.newInteger(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractIntegerAssert#isBetween} */
  public IntegerAssert isBetween(Integer start, Integer end) {
    segment("isBetween")
        .argument(DynamicProperty.newInteger(start))
        .argument(DynamicProperty.newInteger(end));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractIntegerAssert#isStrictlyBetween} */
  public IntegerAssert isStrictlyBetween(Integer start, Integer end) {
    segment("isStrictlyBetween")
        .argument(DynamicProperty.newInteger(start))
        .argument(DynamicProperty.newInteger(end));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractIntegerAssert#isCloseTo} */
  public IntegerAssert isCloseTo(Integer expected, Offset offset) {
    segment("isCloseTo")
        .argument(DynamicProperty.newInteger(expected))
        .argument(DynamicProperty.newOffset(offset));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractIntegerAssert#isNotCloseTo} */
  public IntegerAssert isNotCloseTo(Integer expected, Offset offset) {
    segment("isNotCloseTo")
        .argument(DynamicProperty.newInteger(expected))
        .argument(DynamicProperty.newOffset(offset));
    return this;
  }
}